# HG changeset patch # User Dremov Kirill (Nokia-D-MSW/Tampere) # Date 1274786578 -10800 # Node ID da2cedce4920f4736258898f04d1af0dd23e9307 # Parent d27dfa8884ad51236e042cc19a2be3a72a3eaded Revision: 201019 Kit: 2010121 diff -r d27dfa8884ad -r da2cedce4920 analyzetool/analyzetoolcleaner/bwins/atoolcleaneru.def --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/analyzetoolcleaner/bwins/atoolcleaneru.def Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,3 @@ +EXPORTS + ?GetCallBackAddress@@YAPAV?$TFixedArray@K$09@@XZ @ 1 NONAME ; class TFixedArray * GetCallBackAddress(void) + diff -r d27dfa8884ad -r da2cedce4920 analyzetool/analyzetoolcleaner/eabi/atoolcleaneru.def --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/analyzetoolcleaner/eabi/atoolcleaneru.def Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,3 @@ +EXPORTS + _Z18GetCallBackAddressv @ 1 NONAME + diff -r d27dfa8884ad -r da2cedce4920 analyzetool/analyzetoolcleaner/group/analyzetoolcleaner.mmp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/analyzetoolcleaner/group/analyzetoolcleaner.mmp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,39 @@ +/* +* 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: The .mmp file for atoolcleaner. +* +*/ + +#include + +TARGET atoolcleaner.dll +TARGETTYPE dll +UID 0x1000008d 0x2002DC71 +CAPABILITY ALL -TCB +EPOCALLOWDLLDATA + +SMPSAFE + +SOURCEPATH ../src +SOURCE analyzetoolcleaner.cpp + +USERINCLUDE ../inc +USERINCLUDE ../../inc + +OS_LAYER_SYSTEMINCLUDE + +LIBRARY euser.lib +LIBRARY flogger.lib + +// End of File diff -r d27dfa8884ad -r da2cedce4920 analyzetool/analyzetoolcleaner/group/bld.inf --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/analyzetoolcleaner/group/bld.inf Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,8 @@ +PRJ_PLATFORMS +ARMV5 WINSCW + +PRJ_EXPORTS +../inc/analyzetoolcleaner.h OS_LAYER_PLATFORM_EXPORT_PATH(analyzetool/analyzetoolcleaner.h) + +PRJ_MMPFILES +analyzetoolcleaner.mmp diff -r d27dfa8884ad -r da2cedce4920 analyzetool/analyzetoolcleaner/inc/analyzetoolcleaner.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/analyzetoolcleaner/inc/analyzetoolcleaner.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,63 @@ +/* +* 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 TAnalyzeToolCleanerBase. +* +*/ + +#ifndef __ANALYZETOOLCLEANER_H__ +#define __ANALYZETOOLCLEANER_H__ + +// INCLUDES +#include + +// CONSTANTS +#define ATCLEANERTABLESIZE 10 +#define ATCLEANERTABLE TFixedArray +_LIT( KATCleanerDllName, "atoolcleaner.dll" ); + +// CLASS DECLARATION + +/** +* Cleaner base class +*/ +class TAnalyzeToolCleanerBase + { +public: + /** + * Cleanup function which uninstall allocator + */ + virtual void Cleanup() = 0; + }; + +// CLASS DECLARATION + +/** +* Cleaner class +*/ +class THookCleaner + { +public: + /** + * C++ default constructor. + */ + THookCleaner(); + + /** + * Destructor. + */ + ~THookCleaner(); + + ATCLEANERTABLE iTable; + }; +#endif // __ANALYZETOOLCLEANER_H__ diff -r d27dfa8884ad -r da2cedce4920 analyzetool/analyzetoolcleaner/src/analyzetoolcleaner.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/analyzetoolcleaner/src/analyzetoolcleaner.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,67 @@ +/* +* 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: THookCleaner implementation +* +*/ + +// INCLUDES +#include "analyzetoolcleaner.h" +#include +#include "atlog.h" + +// Global cleaner object +static THookCleaner cleaner; + +// ordinal 1 +EXPORT_C ATCLEANERTABLE* GetCallBackAddress() + { + LOGSTR1( "ATC GetCallBackAddress()" ); + + return &( cleaner.iTable ); + } + +// ----------------------------------------------------------------------------- +// THookCleaner::THookCleaner() +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +THookCleaner::THookCleaner() + { + LOGSTR1( "ATC THookCleaner::THookCleaner()" ); + + iTable.Reset(); + } + +// ----------------------------------------------------------------------------- +// THookCleaner::~THookCleaner() +// Destructor. +// ----------------------------------------------------------------------------- +// +THookCleaner::~THookCleaner() + { + LOGSTR1( "ATC THookCleaner::~THookCleaner()" ); + + for ( TUint i = 0; i < ATCLEANERTABLESIZE; i++ ) + { + if ( iTable.At( i ) ) + { + TAnalyzeToolCleanerBase* obj = + ( TAnalyzeToolCleanerBase* ) iTable.At( i ); + obj->Cleanup(); + } + } + } + +// End of File diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/group/atool.vcproj --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/group/atool.vcproj Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,375 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/group/bld.inf --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/group/bld.inf Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,22 @@ +/* +* 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: +* +*/ + + +PRJ_EXPORTS +../install/atool.exe +/tools/ +../install/addr2line.exe +/tools/ +../install/xerces-c_2_7.dll +/tools/ diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/inc/ATCommonDefines.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/inc/ATCommonDefines.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,598 @@ +/* +* 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: Common defines for cpp files. +* +*/ + + +#ifndef __ATCOMMONDEFINES_H__ +#define __ATCOMMONDEFINES_H__ + +#include "../inc/stdafx.h" + +using namespace std; + +/** +* Atool return code. +*/ +struct AT_RETURN_CODE { + /** + * Enumeration containing all return codes used by atool. + * When error happens this value set as the exit code. + * Note! Values can be only added not modified/deleted. + */ + enum RETURN_CODE { + /* basic */ + OK = 0, /** All ok. */ + INVALID_ARGUMENT_ERROR = 1, /** Arguments failty. */ + AT_LIBS_MISSING = 2, /** Missing at libraries cannot compile hooked apps. */ + CANNOT_FIND_EPOCROOT = 3, /** Epocroot not set. */ + UNHANDLED_EXCEPTION = 4, /** General return code when unhandled exception occurs. */ + /* compile errors */ + MAKEFILE_ERROR = 5, /** Cannot read/create etc makefiles sbs1/2. */ + COMPILE_ERROR = 6, /** Some error related to compilation of code. */ + UNKNOWN = 7, /** General compilation error not specific. */ + NO_SUPPORTED_MODULES_ERROR = 8, /** Cannot find supported modules from project. */ + KERNEL_SIDE_MODULE_ERROR = 9, /** Cannot find supported modules from project because kernel side. */ + /* Analyze errors */ + WRONG_DATA_FILE_VERSION = 10, /** Invalid data file version in internal gathering mode. */ + INVALID_DATA_FILE = 11, /** Data file content invalid. */ + ANALYZE_ERROR = 12, /** General error in analyze part not specific. */ + EMPTY_DATA_FILE = 13, /** Data file is empty. */ + SYMBOL_FILE_ERROR = 14, /** Symbol file content invalid or do not exist. */ + /* building&releasing errors */ + RELEASABLES_ERROR = 20, /** Cannot find the binaries of module. */ + RESTORE_MODULES_ERROR = 21, /** Error restoring mmp file to original. */ + CREATING_TEMP_CPP_ERROR = 22, /** Error creating temporary cpps to store variables to s60 core.*/ + CLEANING_TEMP_ERROR = 23, /** Error cleaning atool_temp folder from module. */ + READ_MAKEFILE_ERROR = 24, /** Some error when reading makefile of module / project (sbs1/2). */ + MODIFY_MODULES_ERROR = 25, /** Error modifying module mmp file. */ + INVALID_MMP_DEFINED = 27, /** Specified module does not exist in project. */ + /* Attribute file related */ + WRITE_ATTRIBUTES_ERROR = 30, /** Error writing the cfg file into atool_temp folder (contains arguments).*/ + READ_ATTRIBUTES_ERROR = 31, /** Error reading hooking related arguments from cfg file. */ + /* User issued exit */ + USER_ISSUED_EXIT = 40, /** User aborted the run of application. */ + }; +}; + +// Debug logging to console +extern bool g_bDebugConsole; +// Debug logging to windows api debug +extern bool g_bDebugDbgView; +// Debug (low level functions). +extern bool g_bDebugLowLevel; + +// Temporary directory definition's. +const char AT_TEMP_DIR[] = "atool_temp"; +const char AT_TEMP_LST_DIR[] = "atool_temp\\static_lsts\\"; + +// makefile dir is used in atool.cpp to check will we use sbs2 (in analyze and clear) +#define RAPTOR_MAKEFILE_DIR "atool_temp\\build" + +// Atool version number and date +#define ATOOL_VERSION "1.9.1" // NOTE! This version number is written also to temporary cpp file. +#define ATOOL_DATE "29th April 2010" + +// Default/min/max call stack sizes +const int AT_ALLOC_CALL_STACK_SIZE_DEFAULT = 40; +const int AT_FREE_CALL_STACK_SIZE_DEFAULT = 0; +const int AT_CALL_STACK_SIZE_MIN = 0; +const int AT_CALL_STACK_SIZE_MAX = 256; + +// What version of data file contains timestamps in dll's. +const int AT_DLL_TIMESTAMP_DATA_VERSION = 2; + +// Constant compatibility string in temporary cpp. +// Api version ; current version. +#define ATOOL_COMPATIBILITY_STRING "1.7.5;1.9.1" + +// Datafile version +#define AT_DATA_FILE_VERSION "DATA_FILE_VERSION 11" + +// Latest dbghelp.dll version +const int DBGHELP_VERSION_MAJ = 6; +const int DBGHELP_VERSION_MIN = 3; +const int DBGHELP_VERSION_BUILD = 0; +const int DBGHELP_VERSION_REVIS = 0; +const char DBGHELP_DLL_NAME[] = "dbghelp.dll"; + + +// Build summary constants +const string AT_BUILD_SUMMARY_HEADER = "\n### AnalyzeTool ###\n### Build Summary ###\n\n"; +const string AT_BUILD_SUMMARY_INSTRUMENTED_BUILD_COMPLETE = "Instrumented build complete: "; +const string AT_BUILD_SUMMARY_TARGET = "\tTarget: "; +const string AT_BUILD_SUMMARY_FAILED = "Build failed: "; +const string AT_BUILD_SUMMARY_ERRORS = "\tErrors: "; +const string AT_BUILD_SUMMARY_DATA_FILE_NAME = "\tInternal data gathering filename: "; +const string AT_BUILD_SUMMARY_NORMAL_BUILD_COMPLETE = "Normal build complete: "; +const string AT_BUILD_SUMMARY_STATIC_LIBRARY = "\tModule is static library."; +const string AT_BUILD_SUMMARY_UNSUPPORTED_TARGET_TYPE = "\tModule has unsupported target type."; +const string AT_BUILD_SUMMARY_UNSUPPORTED_COMPILE_DEFINITION = "\tModule defined unsupported compile definition."; +const string AT_BUILD_SUMMARY_BUILD_TYPE = "Build type: "; +const string AT_BUILD_SUMMARY_BUILD_TARGET = "Build target: "; +const string AT_BUILD_SUMMARY_BUILD_PLATFORM = "Build platform: "; +const string AT_BUILD_SUMMARY_BUILD_VARIANT = "Build variant: "; +const string AT_BUILD_SUMMARY_LOGGING_MODE = "Data gathering mode: "; +const string AT_BUILD_SUMMARY_ALLOC_CALL_STACK_SIZE = "Allocation call stack size: "; +const string AT_BUILD_SUMMARY_FREE_CALL_STACK_SIZE = "Free call stack size: "; +const string AT_BUILD_SUMMARY_FILE = "monitored internal"; +const string AT_BUILD_SUMMARY_TRACE = "monitored external"; +const string AT_BUILD_SUMMARY_TRACE_FAST = "external"; + +const string AT_UNSUPPORTED_TARGET_TYPE = "\tModule has unsupported target type."; +const string AT_UNSUPPORTED_COMPILE_DEFINITION = "\tModule defined unsupported compile definition."; + +// List of locations under epocroot where analyzetool.h can be found. +// Add all possible to this list so core version information can be read +// from file. +const string AT_CORE_INCLUDE_FILE_WITH_VERSION_NUMBER[] = { + "epoc32\\include\\domain\\osextensions\\analyzetool\\analyzetool.h", + "epoc32\\include\\oem\\analyzetool\\analyzetool.h", + "epoc32\\include\\platform\\analyzetool\\analyzetool.h" +}; +const string AT_CORE_VERSION_NUMBER_TAG = "ANALYZETOOL_CORE_VERSION_FOR_CLE"; + +// Temporary cpp name +const char AT_TEMP_CPP_LOWER_START[] = "0a1b2c3d_atool_temp_"; +const char AT_TEMP_CPP_LOWER_END[] = ".cpp"; + +const char TAB_CHAR_VALUE = 9; +const char SPACE_CHAR_VALUE = 32; + +// Bldmake error msg +#define AT_BLDMAKE_ERROR "AnalyzeTool : bldmake bldfiles error.\n" + +// File copy/move/etc... message definitions +#define AT_MSG "AnalyzeTool : " +#define AT_MSG_SYSTEM_CALL "AnalyzeTool : System call, " +#define AT_FILE_TO " to " + +// -c messages +#define AT_CLEANING_DONE "AnalyzeTool : Cleaning done." +#define AT_CLEANING_NOTHING_FOUND "AnalyzeTool : Nothing found to clean." + +// Analyzing data without process start or dll load +#define AT_ANALYZE_INSUFFICIENT_LOGGING_DATA "Insufficient logging data to locate code lines for memory addresses.\nLogging has been started after process start." +#define AT_ANALYZE_NO_PROCESS_START "AnalyzeTool : No processes start information found in test run data." +#define AT_ANALYZE_NO_DLL_LOAD "AnalyzeTool : No dll load information found in test run data." +#define AT_ANALYZE_CANNOT_PINPOINT "AnalyzeTool : Memory addresses cannot be pinpointed." +#define AT_ANALYZE_ABNORMAL_EXIT "Abnormal process end" + +// Analyzing without map / lst files +#define AT_ANALYZE_MISSING_LST_MAP_FILES "AnalyzeTool : Missing lst or map files, memory addresses shown only to module level.\n" +//#define AT_UNINSTRUMENT_FAILED_IN_ANALYZE_MESSAGE "AnalyzeTool: Error creating map/lst files, leaks shown only to module level.\nRun atool -u to try create lst/map files again after binaries build successfully.\n" + +// Mmp error msg +#define INVALID_MMP_ERROR "AnalyzeTool : Error, Specified mmp is invalid.\n" + +// Make error msg +#define MAKE_ERROR "AnalyzeTool : Error, Running make.\n" + +#define AT_NOT_BEEN_BUILD_ERROR "AnalyzeTool : Error, project has not been build using AnalyzeTool.\n" + +// Makefile errors +#define LEVEL1_MAKEFILE_ERROR "AnalyzeTool : Error, reading level 1 makefile.\n" +#define LEVEL2_MAKEFILE_ERROR "AnalyzeTool : Error, reading level 2 makefile.\n" +#define MAKEFILE_ERROR_TIP "AnalyzeTool : Tip, your environment might require you to use -variant [target] argument.\n"; + +//Variant messages +#define INVALID_VARIANT_ERROR "AnalyzeTool : Error,Specified variant is invalid.\n" +#define USING_DEFAULT_VARIANT_MESSAGE "AnalyzeTool : Note, Using DEFAULT variant.\n" +#define NO_DEFAULT_VARIANT_ERROR "AnalyzeTool : Error, environment does not specify DEFAULT variant (No variant support?).\n" + +// Variant dir is the dir where all variants are defined +#define VARIANT_DIR "\\epoc32\\tools\\variant\\" + +// Variants defined extension name of the variant must equal filename +#define VARIANT_FILE_EXTENSION ".VAR" + +//Max file name length +const int MAX_FILENAME_LENGTH = 1024; + +//Max line length when reading lines from text file.2048 should be enought. +const int MAX_LINE_LENGTH = 2048*8; + +// ATs project file name to store project attributes +#define AT_PROJECT_ATTRIBUTES_FILE_NAME "project.cfg" +const string AT_PROJECT_ATTRIBUTES_SEPARATOR( ":$:" ); + +// ATs level1 makefile name +#define AT_LEVEL_1_MAKEFILE_NAME "main.at" + +// ATs level2 makefiles extension +#define AT_LEVEL_2_MAKEFILE_EXT "atm" + +//Default logging level +const int DEFAULT_LOGGING_LEVEL = 3; + +//Minimun value of logging level +const int MIN_LOGGING_LEVEL = 0; + +//Maximun value of logging level +const int MAX_LOGGING_LEVEL = 3; + +//Const char represeting dash +const char DASH = '\\'; + +/** + * Table of file extension not to delete + * from atools temp directory when compiling + * note define all in lowercase + */ +const string TEMP_EXTENSION_NO_DELETE[] = { + "xml", + "dat", + "tmp", + "cpp", + "at", + "atm", + "cfg" +}; + +// Allowed characters/digits, other than these will be filtered out when using CATBase FilterString +const char CFILTERSTRING[] = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_"; + +/** + * Table of unsupported target types + * (i.e. mmp file syntax targettype in makefile) + * List of target types which will not be hooked: +*/ +const string UNSUPPORTED_TARGET_TYPES[] = { + "CTL", + "ECOMIIC", + "IMPLIB", + "KDLL", + "KEXT", + "KLIB", + "LDD", + /* "LIB", currently have own vector in project.*/ + "MDA", + "MDL", + "NONE", + "NOTIFIER", + "PDD", + "RDL", + "STDLIB", + "VAR" +}; + +/** +* Kernel side target types +*/ +const string KERNEL_SIDE_TARGET_TYPES[] = { + "VAR", + "LDD", + "PDD", + "KEXT" +}; + +// Kernel mode compile definition +const string KERNEL_MODE_COMPILE_DEFINITION = "__KERNEL_MODE__"; + +/** +* MMP file changes for AT +* Note "SOURCE 0a1b2c3d_atool_temp_TARGET.cpp" is added also. +*/ +const string MMPFILECHANGES[] = { + "//*** AnalyzeTool changes start ***", + "SOURCEPATH atool_temp", + "LIBRARY AToolMemoryHook.lib", + "STATICLIBRARY AToolStaticLib.lib", + "OPTION ARMCC --interleave", + "//*** AnalyzeTool changes end ***" +}; + +//MMP file changes for AT +//For targettype Dll +const string MMPFILECHANGES_DLL[] = { + "//*** AnalyzeTool changes start ***", + "OPTION ARMCC --interleave", + "//*** AnalyzeTool changes end ***" +}; + +// Trace file constants definitions +#define LABEL_DATA_FILE_VERSION "DATA_FILE_VERSION" +#define LABEL_PROCESS_START "PROCESS_START" +#define LABEL_DLL_LOAD "DLL_LOAD" +#define LABEL_DLL_UNLOAD "DLL_UNLOAD" +#define LABEL_MEM_LEAK "MEM_LEAK" +#define LABEL_PROCESS_END "PROCESS_END" +#define LABEL_ERROR_OCCURED "ERROR_OCCURED" +#define LABEL_HANDLE_LEAK "HANDLE_LEAK" +#define LABEL_TEST_START "TEST_START" +#define LABEL_TEST_END "TEST_END" +#define LABEL_LOGGING_CANCELLED "LOGGING_CANCELLED" + +// AddressToLine related constants + +#define LABEL_ABNORMAL "ABNORMAL" +const int FUNCTIONS_OFFSET_IN_MAP_FILE_ARMV5 = 0x8000; +const int FUNCTIONS_OFFSET_IN_GCCE = 0x8000; +const int FUNCTIONS_OFFSET_IN_MAP_FILE_WINSCW = 0x400000; +#define TEXT_NO_HANDLE_LEAKS "No handle leaks." + +// Make file constant labels +#define MAKEFILE_TARGETTYPE_STRING "# TargetType " +#define MAKEFILE_BASIC_TARGETTYPE_STRING "# BasicTargetType " +#define MAKEFILE_TARGET_STRING "# Target " +#define MAKEFILE_FEATURE_VARIANT_NAME "# FeatureVariantName " +#define MAKEFILE_FEATURE_VARIANT_UREL_LABEL "# FeatureVariantURELLabel " +#define MAKEFILE_FEATURE_VARIANT_UDEB_LABEL "# FeatureVariantUDEBLabel " +#define UDEB_OPTIMIZATION_LEVEL 0 + +// Listing file contant labels +#define LST_FILE_SOURCE_FILE_LABEL "Source file:" + +/** +* Struct for saving module info from .dat file and number of leaks in module. +*/ +struct DLL_LOAD_INFO +{ + string sModuleName; /** name of the code segment/binary */ + unsigned long iStartAddress; /** start address of code segment (in memory) */ + unsigned long iEndAddress; /** end address of code segment (in memory) */ + int iLeaks; /** leak count in this code segment */ + unsigned long iPID; /** process id which loaded this code segment */ + int iSubTestStartOpenHandles; /** open handle count when sub test started */ + int iSubTestEndOpenHandles; /** open handle count when sub test ended */ + // Load/Unload times, note these are micro seconds from 1970 so size is huge. + unsigned long long iLoadTime; /** code segment load time */ + unsigned long long iUnloadTime; /** code segment unload time */ + /** + * Default constructor to set default values + */ + DLL_LOAD_INFO() { + iStartAddress = 0; + iEndAddress = 0; + iLeaks = 0; + iPID = 0; + iSubTestStartOpenHandles = 0; + iSubTestEndOpenHandles = 0; + iLoadTime = 0; + iUnloadTime = 0; + }; +}; + +/** +* Struct for saving symbol information from listing file +*/ +struct LINE_IN_FILE +{ + int iLine; /** line number */ + string sFileName; /** filename */ + string sFunction; /** function / symbol */ + string sMangledName; /** function / symbol name in mangled / coded form */ + string sLstName; /** listing filename */ +}; + +/** +* Struct for saving symbol information from map file +*/ +struct MAP_FUNC_INFO +{ + int iAddress; /** memory address (start of symbol) */ + int iFuncLength; /** symbol length */ + string sMangledName;/** symbol name in mangled / coded form */ + string sWholeLine; /** whole symbol line from map file */ + string sFunctionName; /** symbol clear name */ +}; + +/** +* State that represents the outcome +* of locating memory address code line from module +*/ +enum ADDRESS_TO_LINE_STATE { + no_map_data = 0, /** Map data was missing */ + out_of_function_range, /** Could not locate it to any function */ + mangled_symbol_name, /** symbol name but mangled / coded form */ + only_function_name, /** Only got function name not code line */ + succesfull /** Have line number, function, etc...*/ +}; + +/** +* Struct to store detail data and state when +* locating memory addresses code lines +*/ +struct ADDRESS_TO_LINE_ITEM { + ADDRESS_TO_LINE_STATE eState; /** outcome */ + string sFileName; /** Filename of address */ + string sFunctionName; /** Function name of address */ + string sMangledFunctionName; /** function/Symbol name */ + int iFunctionLineNumber; /** Functions line number */ + int iExactLineNumber; /** Exact line number of address */ +}; + +/** +* Struct to store memory leaks +* call stack entry data +*/ +struct CALL_STACK_ITEM { + string sAddress; /** Address in string */ + int iAddress; /** Address in number (converted)*/ + int iLocation; /** Location. i.e. corresponds m_vDllLoadModList's index*/ + int iCalculatedLeakAddress; /** calculated address from code segment start */ + bool bBuildUdeb; /** Optimization level */ + string sModuleName; /** Modules name were leak is*/ + ADDRESS_TO_LINE_ITEM addressToLine; /** Data from locating code line for memory address */ +}; + +/** +* Enumerations used in argument structure. +*/ +enum MAIN_SWITCH +{ + SWITCH_UNKNOWN = 0, /** not defined */ + SWITCH_ANALYZE = 1, /** analyze */ + SWITCH_HOOK = 2, /** compile/instrument */ + SWITCH_UNHOOK = 3, /** uninstrument */ + SWITCH_PARSE_TRACE = 5, /** parse raw data */ + SWITCH_CLEAN = 6, /** clean AT changes */ + SWITCH_VERSION = 9, /** display version infromation */ + SWITCH_HELP = 10, /** show help with syntax examples */ + SWITCH_DBGHELP_VERSION = 11 +}; + +/** +* Enumeration used when hooking project. +*/ +enum HOOK_SWITCH +{ + HOOK_UNKNOWN = 0, /** not defined */ + HOOK_INTERNAL, /** monitored internal data gathering */ + HOOK_EXTERNAL, /** monitored external data gathering */ + HOOK_EXTERNAL_FAST, /** external data gathering */ + HOOK_EXTENSION_INTERNAL, /** Extension call, monitored internal data gathering */ + HOOK_EXTENSION_EXTERNAL, /** Extension call, monitored external data gathering */ + HOOK_EXTENSION_EXTERNAL_FAST, /** Extension call, external data gathering */ + HOOK_EXTENSION_UNINSTRUMENT, /** Extension call, uninstrument (post-build)*/ + HOOK_EXTENSION_FAILED, /** Extension call, build failed, cleanup */ + HOOK_OLD_EXTENSION_INSTRUMENT, /** Old extension call, instrument project */ + HOOK_OLD_EXTENSION_UNINSTRUMENT, /** Old extension call, uninstrument project */ + HOOK_OLD_EXTENSION_FAILED /** Old extension call, cleanup */ +}; + +/** +* Represents hooking parameters, these are set +* by the user arguments from command line. +*/ +struct ARGUMENTS_HOOK +{ + bool bNoBuild; /** Only intrument project? (no build) */ + bool bDataFileName; /** Is internal data gathering filename defined */ + bool bAbldTest; /** Is build only for test modules (abld test build.. */ + string sDataFileName; /** Internal data gathering filename */ + int iBuildSystem; /** 1 = sbs, 2 = raptor */ + int iLoggingMode; /** Just for old parameter parsing. 1=trace, 2=file, 0=? */ + int iAllocCallStackSize; /** Call stack size when memory allocated */ + int iFreeCallStackSize; /** Call stack size when memory freed */ + string sBuildCmd; /** Original build command / user defined or given */ + vector vBuildCmd; /** Build command split in vector */ + string sPlatform; /** Build platform */ + string sBuildType; /** Build type (udeb/urel) */ + string sFeatureVariant; /** Build variant defined */ + vector vTargetPrograms; /** User defined single or multiple modules from project? */ + /** + * Default constructor to set default values. + */ + ARGUMENTS_HOOK() + { + bNoBuild = false; + bAbldTest = false; + bDataFileName = false; + sDataFileName = ""; + iBuildSystem = 0; + iLoggingMode = 0; + iAllocCallStackSize = AT_ALLOC_CALL_STACK_SIZE_DEFAULT; + iFreeCallStackSize = AT_FREE_CALL_STACK_SIZE_DEFAULT; + sBuildCmd = ""; + sPlatform = ""; + sBuildType = ""; + sFeatureVariant = ""; + vTargetPrograms.clear(); + }; +}; + +/** +* Represents analyze parameters, these are set +* by the user arguments from command line. +*/ +struct ARGUMENTS_ANALYZE +{ + string sDataFile; /** Data file to be analyzed */ + string sOutputFile; /** Output file */ + bool bSymbolFile; /** Is rom/rofs symbol file(s) defined? */ + vector vSymbolFiles; /** Collection of symbol files */ + int iLoggingLevel; /** Logging level of report */ + /** + * Default constructor to set default values. + */ + ARGUMENTS_ANALYZE() + { + sDataFile = ""; + sOutputFile = ""; + bSymbolFile = false; + iLoggingLevel = 3; + }; +}; + +/** +* Represents raw trace parsing parameters, these are set +* by the user arguments from command line. +*/ +struct ARGUMENTS_PARSE +{ + bool bDataFile; /** Is raw data file defined */ + string sDataFile; /** Raw data file (input) */ + bool bOutputFile; /** Is output file defined */ + string sOutputFile; /** Output (AT specific data file)*/ + /** + * Default constructor to set default values. + */ + ARGUMENTS_PARSE() + { + bDataFile = false; + sDataFile = ""; + bOutputFile = false; + sOutputFile = ""; + }; +}; + + +/** +* Represents main parameters, these are set +* by the user arguments from command line. +*/ +struct ARGUMENTS +{ + // Base arguments. + MAIN_SWITCH eMainSwitch; /** mandatory/main parameter */ + HOOK_SWITCH eHookSwitch; /** if compile/instrument its "mode" */ + bool bHelp; /** show help? */ + bool bDebugConsole; /** enable debug logging to console? */ + bool bDebugDbgView; /** enable debug logging to win api? */ + bool bDebugLowLevel; /** enable debug logging for also low level functions? */ + bool bEnableSbs2; /** use raptor as build system? */ + ARGUMENTS_HOOK HOOK; /** hooking/instrument/compiling attributes */ + ARGUMENTS_ANALYZE ANALYZE; /** analyze related attributes */ + ARGUMENTS_PARSE PARSE; /** parsing related attributes */ + /** + * Default constructor to set default values. + */ + ARGUMENTS() + { + eMainSwitch = SWITCH_UNKNOWN; + eHookSwitch = HOOK_UNKNOWN; + bHelp = false; + bDebugConsole = false; + bDebugDbgView = false; + bEnableSbs2 = false; + }; +}; + +// DEBUG MACROS +// constant string for all beginning of all debug messages +const char START_LOG_MESSAGE[] = "*** CLE "; +// Log normal function entry (AAA = class::function ) +#define LOG_FUNC_ENTRY( AAA ) { if( g_bDebugDbgView) { stringstream strs; strs << START_LOG_MESSAGE << "ENTRY: " << AAA << endl; OutputDebugString( strs.str().c_str() ); } else if ( g_bDebugConsole ) { stringstream strs; strs << START_LOG_MESSAGE << "ENTRY: " << AAA << endl; cout << strs.str(); } } +// Log normal function exit +#define LOG_FUNC_EXIT( AAA ){ if( g_bDebugDbgView) { stringstream strs; strs << START_LOG_MESSAGE << "EXIT: " << AAA << endl; OutputDebugString( strs.str().c_str() ); } else if ( g_bDebugConsole ) { stringstream strs; strs << START_LOG_MESSAGE << "EXIT: " << AAA << endl; cout << strs.str(); } } +// Log low level function entry +#define LOG_LOW_FUNC_ENTRY( AAA ) { if ( g_bDebugLowLevel ) { if( g_bDebugDbgView) { stringstream strs; strs << START_LOG_MESSAGE << AAA << endl; OutputDebugString( strs.str().c_str() ); } else if ( g_bDebugConsole ) { stringstream strs; strs << START_LOG_MESSAGE << AAA << endl; cout << strs.str(); } } } +// Log low level function exit +#define LOG_LOW_FUNC_EXIT( AAA ) { if ( g_bDebugLowLevel ) { if( g_bDebugDbgView) { stringstream strs; strs << START_LOG_MESSAGE << AAA << endl; OutputDebugString( strs.str().c_str() ); } else if ( g_bDebugConsole ) { stringstream strs; strs << START_LOG_MESSAGE << AAA << endl; cout << strs.str(); } } } +// Log stringstream (string, int, etc..) i.e. string1 << int1 << "log this" +#define LOG_STRING( AAA ) { if( g_bDebugDbgView) { stringstream strs; strs << START_LOG_MESSAGE << AAA << endl; OutputDebugString( strs.str().c_str() ); } else if ( g_bDebugConsole ) { stringstream strs; strs << START_LOG_MESSAGE << AAA << endl; cout << strs.str(); } } + +#endif \ No newline at end of file diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/inc/CATBase.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/inc/CATBase.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,418 @@ +/* +* 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: Defines CATBase "utility" class. +* +*/ + +#ifndef __CATBASE_H__ +#define __CATBASE_H__ + +#include "../inc/ATCommonDefines.h" + +/** +* This class implements lot of utility type of functions used all around atool project. +* All functions are static so they can be used without inheritance of this class. But still +* this is a base class of almost all others. +*/ +class CATBase +{ +public: + + /** + * Constructor + */ + CATBase(); + + /** + * Destructor + */ + virtual ~CATBase(void); + +public: + + /** + * FilterExtraSpaces + * Filters/replaces multiple continuous spaces with single. Won't leave + * spaces in start or end of string. + * @param sString to filter. + * @return void. + */ + static void FilterExtraSpaces( string& sString ); + + /** + * Convert hex value in string to signed decimal. + * @param sHex + * @param iDec + * @return true if successful + */ + static bool hexToDec( string& sHex, int& iDec ); + + /** + * Convert hex value in string to unsigned decimal + * @param sHex + * @param iDec + * @return true if successful + */ + static bool hexToDec( string& sHex, unsigned int& iDec ); + + /** + * Convert hex value in string to unsigned long. + * @param sHex + * @param ulDec + * @return true if successful + */ + static bool hexToDec( string& sHex, unsigned long& ulDec ); + + /** + * Convert hex value in string to unsigned long long. + * @param sHex + * @param ullDec + * @return true if successful + */ + static bool hexToDec( string& sHex, unsigned long long& ullDec ); + + /** + * Convert hex value to integer + * @param value + * @return unsigned long + */ + static unsigned long _httoi(const TCHAR *value); + + /** + * Convert integer to hex string. + * @param i + * @return hex string + */ + static string NumberToHexString( unsigned int i ); + + /** + * Convert long to hex string. + * @param i + * @return hex string + */ + static string NumberToHexString( unsigned long i ); + + /** + * Helper function checks is given character hex. + * @param value value to check. + * @return true if value is hex char. + */ + static bool IsHexCharacter(const TCHAR *value); + + /** + * Parse string to vector of strings using + * separator. (Tokenizer with delimeter). + * @param sInput string to split + * @char separator + * return vector + */ + static vector ParseStringToVector( const string& sInput, char separator ); + + /** + * Remove spaces and tabulatures from beginning and + * end of given string. + * @param sInput String to trim. + */ + static void TrimString( string& sInput ); + + /** + * Searches files with given extension from path. + * @param pPathAndExt path with extension + * @return string filename + */ + static string GetFileNameUsingExt( const char* pPathAndExt ); + + /** + * Changes all BackSlash characters to Slash character from string. + * @param sInput String including backslashes. + * @return String without backslashes. + */ + static string ChangeSlashToBackSlash( string sInput ); + + /** + * Changes given string to uppercase + * @param sInput + */ + static void ChangeToUpper( string& sInput ); + + /** + * Converts any uppercase letter to lowercase. + * + * @param sInput Reference to string. + */ + static void ChangeToLower( string& sInput ); + + /** + * Filter string out of unwanted characters. The list of allowed + * characters is defined in CFILTERSTRING. + * @param sString string to filter. + * @return filtered string. + */ + static string FilterString( const string& sString ); + + /** + * Removes path and extension from given filename string + * @param sFileName + * @param bReverseFindExt if true extension will be looked starting from end + * @return string + */ + static string RemovePathAndExt( string sFileName, bool bReverseFindExt = false ); + + /** + * Check if given file exists. + * @param pFilename Pointer to file name. + * @return False If file does not exists. + */ + static bool FileExists( const char* pFilename ); + + /** + * Check if given file is flagged read only. + * @param pFileName pointer to file name + * @return true if read only flag set. + */ + static bool IsFileReadOnly( const char* pFileName ); + + /** + * Set file read only. + * @param pFileName Pointer to file name + * @return true if successful. + */ + static bool SetFileReadOnly( const char* pFileName ); + + /** + * Set file writable (remove read only flag). + * + * @param pFilename Pointer to file name. + * @return true if successful. + */ + static bool SetFileWritable( const char* pFileName ); + + /** + * Copy file to given path + * @param sFile + * @param sToPath + * @return true if successful + */ + static bool FileCopyToPath(const string& sFile, const string& sToPath); + + /** + * Move file to given path + * @param sFile File to be moved + * @param sToPath path where to move file + * @return true if successful + */ + static bool FileMoveToPath(const string& sFile, const string& sToPath); + + /** + * Delete file + * Note! if file does not exists no error message is displayed + * but function returns false + * @param sFile File to be deleted + * @param bPrint display messages or not, default true + * @return true if successful + */ + static bool FileDelete(const string& sFile, bool bPrint = true ); + + /** + * Delete dir + * Note! if dir does not exists no error message is displayed + * but function returns false. + * This function wont delete directory if string does not contain + * AT_TEMP... + * @param sDir Directory to be deleted + * @param bPrint display message or not, default true + * @return true if successful + */ + static bool DirDelete(const string& sDir, bool bPrint = true ); + + /** + * Create dir + * Note! if dir cannot be created no error message is displayed + * but function returns false. + * @param sDir Directory to be deleted + * @param pPrint display message or not, default true + * @return true if successful + */ + static bool DirCreate(const string& sDir, bool pPrint = true ); + + /** + * Create temp path string for given + * mmpfile (full path+mmpname) + * @param sMmpFileWithPath + * @return string containing full path to + * AnalyzeTool temporary directory + */ + static string CreateTempPath(const string& sMmpFileWithPath); + + /** + * Search files with extensions from given path. + * @param pPathAndExt path with extension definition + * @param bPrintErrors do print errors? + * @param sErrorLog errors + * @return true if found. + */ + static bool SearchFileWithExtension( const char* pPathAndExt, bool bPrintErrors, string& sErrorLog ); + + /** + * Helper function to parse filename or path from given string + * @param bFileName if true returns filename otherwise the path + * @param sInput string where to get path or filename + * @return string filename or path + */ + static string GetPathOrFileName( bool bFileName, string sInput ); + + /** + * Function returns string from begin of given string until next space, + * characters until next space are removed from sInput string. + * + * @param sInput Line where data is separated with spaces. + * @param bEraseFromInput If true characters before space will be removed. + * @return string String until next space. + */ + static string GetStringUntilNextSpace( string& sInput, bool bEraseFromInput = true ); + + /** + * Convert unix path to windows + * @param sPath + */ + static void ConvertUnixPathToWin( string& sPath ); + + /** + * Create Temporary AT Cpp file + * @param sId unique id to add in file name + * @param sPath where to create + * @param sS60FileName of the logging file + * @param iLogOption logging mode + * @param iIsDebug build type + * @param iAllocCallStackSize + * @param iFreeCallStackSize + * @return true if successful + */ + static bool CreateTemporaryCpp( const string& sId + ,const string& sPath + ,const string& sS60FileName + ,int iLogOption + ,int iIsDebug + ,int iAllocCallStackSize + ,int iFreeCallStackSize ); + /** + * Acquire a list of files in given directory + * @param sDirectory can end to \ or x but not to * + * @param bListDirs if true directories will be listed as well, default false + * @param bAddPathToFile if true given sDirectory path is added to file string, default false + * @return vector list of files in folder + */ + static vector DirList(const string& sDirectory, bool bListDirs = false, bool bAddPathToFile = false); + + /** + * Get extension from given "file" string + * returns string after last . if any otherwise returns same + * what was given + * @param sString + * @return string string after last '.' if no '.' returns given string + */ + static string GetExtension(const string& sString); + + /** + * Convert TCHAR pointer to string + * @param charArray to convert + * @return string + */ + static string ConvertTCHARtoString(TCHAR* charArray); + + /** + * if given string contains two dots '.' this will remove + * all characters after first '.' + */ + static void RemoveAllAfterDotIfTwoDots(string& sString); + + /** + * checks given file is it data file + * @param sFile + * @return true if it is datafile + */ + static bool IsDataFile( string sFile ); + + /** + * Parses a path string containing ".." to a valid + * path without relations. If given string does + * not contain relations it will not be changed + * @param sPathString + * @return void + */ + static void ParseRelativePathString(string& sPathString); + + /** + * Remove relative path ".." from string + * @param sString string to remove from + * @param iDots index of ".." + * @return void + */ + static void RemoveRelativePath(string& sString, size_t iDots); + + /** + * Check if given directory exists. + * + * @param pDirname Pointer to directory name. + * @return False If directory does not exists. + */ + static bool DirectoryExists( const char* pDirname ); + + /** + * Checks from constant array is this targettype + * unsupported by AT + * @param sTargetType type to check + * @return true if it is supported by atool + */ + static bool IsTargetTypeSupported(string sTargetType); + + /** + * Checks from constant array is this targettype + * kernel side. + * @param sTargetType type to check + * @return true if it is kernel type + */ + static bool IsTargetTypeKernelSide(string sTargetType); + + /** + * Check is given variant defined in environment.(SBS v.1) + * @param sEpocroot + * @param sVariantName + * @return true if it is. + */ + static bool CheckVariant( const string& sEpocroot, const string& sVariantName ); + + /** + * Check has the environment defined "DEFAULT" variant + * @param sEpocRoot + * @return true if it is + */ + static bool IsDefaultVariant( const string& sEpocRoot ); + + /** + * Check is all character ascii + * @param pInput pointer to characters + * @param iLength length of the string + * @return true if all character are ascii + */ + static bool IsAscii( const char* pInput, const unsigned int iLength ); + + /** + * Get current environments epocroot. + * @param sEpocRoot value is stored in this if successful. + * @return true if successful. + */ + static bool GetEpocRoot( string& sEpocRoot ); +}; +#endif diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/inc/CATDatParser.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/inc/CATDatParser.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,283 @@ +/* +* 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: Defines CATDatParser class and its used enumerations. +* +*/ + + +#ifndef __CATDatParser_H__ +#define __CATDatParser_H__ + +// Includes. +#include "ATCommonDefines.h" +#include "CATBase.h" +#include "CATDataSaver.h" + +// Forward declarations. +class CATModule2; +class CATMemoryAddress; +class CATRomSymbol; + +/** +* Provides the analyze feature for AnalyzeTool specific data file. +* Is used by CATProject. Uses CATModule2 and/or CATRomSymbol to locate symbols or +* codelines of memory addressses. Uses CATDataSaver to create report. +*/ +class CATDatParser : public CATBase +{ + +public: + /** + * enumeration representing the "mode" depending on build system + */ + enum ANALYZE_MODE + { + SBS_1 = 0, + SBS_2 = 1 + }; + /** + * Representing current process state + */ + enum PROCESS_STATE + { + not_started = 0, + ongoing = 1, + stopped = 2 + }; + + /** + * Constructor. + */ + CATDatParser(); + +#ifndef MODULE_TEST +private: +#endif + /** + * Real constructor. + */ + void Construct(); + + /** + * Prevent copy + */ + CATDatParser& operator =( const CATDatParser& /*other*/ ) { } + CATDatParser( const CATDatParser& /*other*/ ) { } + +public: + /** + * Constructor for SBS2 + * @param pModules pointer to vector containing project modules + */ + CATDatParser( vector* pModules ); + + /** + * Destructor + */ + ~CATDatParser(); + + /** + * Set offset to be used with mapfiles + * @param iOffSet + */ + void SetOffSet( int iOffSet ); + + /** + * Get offset value + * @return int + */ + int GetOffSet( ) const; + + /** + * Analyze data file set + * This method includes try/catch in parsing + * @return int error codes specified in CATProject (0=OK) + */ + int Analyze(); + + /** + * Set log level + * @param iLogLevel + */ + void SetLogLevel(int iLogLevel); + /** + * Get Log level + * @return int + */ + int GetLogLevel() const ; + + /** + * Set data file to be analyzed + * @param sInputFile + */ + void SetInputFile(const string& sInputFile); + + /** + * Set output file + * @param sOutputFile + */ + void SetOutputFile(const string& sOutputFile); + + /** + * Set rom symbol file(s). + * @param sRomSymbolFile + */ + void SetRomSymbolFiles(const vector& vRomSymbolFile); + + /** + * Set print flag + * @param pPringFlag + */ + void SetPringFlag( bool bPrintFlag ); + + /** + * Set addr2line.exe pinpoint state + * @param bInput + */ + void SetAddr2lineExeState( bool bInput ); + + /** + * Set project platform. + * @param sPlatform platform. + */ + void SetProjectPlatform( const string& sPlatform ); + + /** + * Set projects build type. Use enumeration defined in CATProject. + * @param eBuildType. + */ + void SetProjectBuildType( int eBuildType ); + +#ifndef MODULE_TEST +private: +#endif + + /** + * Start parsing datafile + * @return error codes defined in CATProject + */ + int Parse(); + + /** + * Helper functio to print header of report + */ + void Header(); + + /** + * Helper functio to print footer of report + */ + void Footer(); + + /** + * Helper function reseting/clearing all + * member variables related to parsing + */ + void ClearParsingVariables(); + + // Helpers for data file tags + bool ParseProcessStart( string& sLine ); + bool ParseDllLoad( string& sLine ); + bool ParseDllUnload( string& sLine ); + bool ParseMemLeak( string& sLine ); + bool ParseProcessEnd( string& sLine ); + bool ParseHandleLeak( string& sLine ); + bool ParseTestStart( string& sLine ); + bool ParseTestEnd( string& sLine ); + bool ParseLoggingCancelled( string& sLine ); + bool ParseErrorOccured( string& sLine ); + + void PrintMemLeak(const string& sTime, + const string& sLeakSize, + const string& sLeakAddr, + const string& sModuleName); + + // Utilities + string ConvertTimeToLocalTime( string sInputTime ); + + /** + * Create a winscw module into pModules vector. + * Used when we have dll load of module not in project to create them + * after this they are used in locating code lines. + * @param sBinaryName name of the binary with extension. + * @return true if successful. + */ + bool CreateWinscwModule( const string& sBinaryName ); + +#ifndef MODULE_TEST +private: +#endif + + void CleanMemoryAddresses(); + + // Members + unsigned int m_iDataVersion; // Version of data file. + int m_eProcess_state; // is process started, etc.. + bool m_bProcessStartFound; + bool m_bDllLoadFound; + int m_iLogLevel; // specified logging level + string m_sInputFile; // input file + vector m_vRomSymbolFiles; // Rom symbol file. + string m_sOutputFile; // output file + string m_sInputFileTemp; // temporary input file (parsed from trace) + ifstream m_In; // Handle to input file + // Datasaver + CATDataSaver m_DataSaver; + + // Modules to be used in pinpointing + vector* m_pModules; + + // Rom symbol file. + CATRomSymbol* m_pRomSymbol; + + // Build type from dat. + int m_eBuildType; + // Build type from project. + int m_eProjectBuildType; + // Offset of map file. + int m_iOffSet; + // Platform of project. + string m_sProjectPlatform; + + // Process related + unsigned long m_iCurrentProcessId; + string m_sCurrentProcessName; + int m_iTotalRuns; + int m_iSuccesfullRuns; + + // Leak counting related + int m_iTotalNumberOfLeaks; + bool m_bSubtestOnGoing; + int m_iPinPointedLeaks; + int m_iPinPointedSubTestLeaks; + int m_iLeakNumber; + + // Handle count related + int m_iSubtestStartHandleCount; + vector m_vHandleLeaks; + + // Module related + vector m_vDllLoadModList; + vector m_vDllLoadModListSubTest; + + // Sbs 1 support functions + int FindModuleUsingAddress( unsigned long iAddress ) const; + //int FindModuleUsingPID( unsigned long iPID ) const; + int FindModuleUsingName( const char* pModName ); + + // Memory addresses + vector m_vMemoryAddress; + +}; +#endif +//EOF diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/inc/CATDataSaver.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/inc/CATDataSaver.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,214 @@ +/* +* 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: Defines CATDataSaver class and element type enumeration. +* +*/ + + +#ifndef __CATDATASAVER_H__ +#define __CATDATASAVER_H__ + +#include +#include +#include "ATCommonDefines.h" + +/** +* Represents element types +*/ +enum element_types +{ + RESULT = 0, + RUN, + LEAK, + CALLSTACK, + ITEM, + RUN_END, + ERROR_IN_RUN, + MEM_LEAKS, + MEM_LEAK_MODULE, + HANDLE_LEAKS, + HANDLE_LEAK_MODULE, + TEST_START, + TEST_END, + SUBTEST_MEM_LEAKS, + SUBTEST_MEM_LEAK_MODULE, + LOGGING_CANCELLED, + SUBTEST_HANDLE_LEAKS +}; + +//#define CARBIDE_DATA 0 +#define XML_DATA 1 +#define TEXT_DATA 2 + +/** +* TProvides features for creating the analyze report in +* basic text or XML formats. Uses xerces library for XML output. +*/ +class CATDataSaver +{ + +public: + + /** + * Constructor. + */ + CATDataSaver( void ); + + /** + * Destructor. + */ + ~CATDataSaver(void); + + /** + * Save all lines to file with given format. + * @param pFileName Pointer to file name. + * @param iDataToSave Format of data. + */ + void SaveLinesToFile( const char* pFileName, int iDataToSave ); + + /** + * Prints all saved lines to screen. + */ + void PrintLinesToScreen( void ); + + /** + * Adds saved line to first in database. + */ + void AddLineToFirst( void ); + + /** + * Adds saved line to last in database. + */ + void AddLineToLast(); + + /** + * Adds string to current line. + * @param pData string to add + * @param bSaveCarbideData add string to xml? + */ + void AddString( const char* pData, bool bSaveCarbideData = false ); + + /** + * Converts integer to string and adds it to current line. + * @param iValue integer value to add + * @param bSaveCarbideData add string to xml? + */ + void AddInteger( int iValue, bool bSaveCarbideData = false ); + + /** + * Sets logging level. + * If value is invalid DEFAULT_LOGGING_LEVEL is used + * value must be between MIN_LOGGING_LEVEL and MAX_LOGGING_LEVEL + * @param iLoggingLevel Logging level. + */ + void SetLoggingLevel( int iLoggingLevel ); + + /** + * Gets logging level. + * @return Logging level. + */ + int GetLoggingLevel( void ); + + /** + * Sets print immediately flag. + * @param bPrintImmediately + */ + void SetPrintFlag( bool bPrintImmediately ); + + /** + * Sets data header for carbide data. + */ + void SaveCarbideDataHeader( void ); + + /** + * Initializes xercer xml parser. + */ + bool InitXML( void ); + + /** + * Writes data to xml tree. + * @param sInput data + * @param iElementType element to write + */ + void SaveXML( string sInput, int iElementType ); + + /** + * Converts char* -> wchar_t*. + * @param str + * @return LPWSTR + */ + static LPWSTR CharToWChar( const char* str ); + + /** + * Converts wchar_t* -> char*. + * @param sInput + * @param Source + */ + static void WCharToChar( string& sInput, const WCHAR* Source ); + + /** + * Set is build type debug? + * @param bUdebBuild true if build type debug + */ + void SetBuild( bool bUdebBuild ); + + /** + * Add xml data for extension + * @param sInput data + */ + void AddCarbideData( const string& sInput ); + + /** + * Convert given integer to string + * @param iValueToConvert + * @return string + */ + static string IntegerToString( int iValueToConvert ); + +#ifndef MODULE_TEST +private: +#endif + vector m_vLines; + string m_sLine; + string m_sCarbideDataLine; + + string m_sCarbideDataHeader; + + int m_iLoggingLevel; + int m_iRunNumber; + bool m_bPrintImmediately; + bool m_bXMLInitOk; + bool m_bUdebBuild; + + xercesc::DOMDocument* m_pDomDoc; + xercesc::DOMElement* m_pRootElem; + xercesc::DOMElement* m_pCurrentLeakElem; + xercesc::DOMWriter* m_Serializer; + xercesc::DOMElement* m_pRunElement; + xercesc::DOMElement* m_pMemoryLeaks; + xercesc::DOMElement* m_pHandleLeaks; + xercesc::DOMElement* m_pCurrentSubTestElem; + xercesc::DOMElement* m_pSubtestMemoryLeaks; + + /** + * Utility to get sub string from string using char as separator + * @param sInput + * @param cCharacter + * @return string + */ + string GetStringUntilNextGivenChar( string& sInput, char cCharacter ); + +}; + +#endif diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/inc/CATMemoryAddress.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/inc/CATMemoryAddress.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,202 @@ +/* +* 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: Defines the CATMemoryAddress class. +* +*/ + + +#ifndef __CATMEMORYADDRESS_H__ +#define __CATMEMORYADDRESS_H__ + +#include "../inc/ATCommonDefines.h" + +/** +* Represents a single memory address / call stack item. +* State tells the "success" of locating the symbol / code line. +* Contains some utility functions used in this feature. +*/ +class CATMemoryAddress +{ +public: + /** + * Enumeration representing the state of locating code lines. + */ + enum ADDRESS_TO_LINE_STATE + { + OUT_OF_PROCESS = 0, /** Not located code line.*/ + OUT_OF_RANGE, /** Outside functions range. */ + SYMBOL, /** Symbol/ Function located (no codeline) */ + FUNCTION, /** Function and line number.*/ + EXACT /** Exact code line located with all information.*/ + }; + /** + * Constructor + * @param sAddress + * @param iOffSet value used if need to use offset value + */ + CATMemoryAddress( string& sAddress, unsigned long iOffSet ); + /** + * Destructor + */ + virtual ~CATMemoryAddress(); + /** + * Find which binary this address belongs to. + * Sets also the offsetfrommodulestart. + * @param vDlls container of binarys to find from. + * @return true if found + */ + bool FindSetModuleName(vector* vDlls); + /** + * Get vector index to which module we found this address to belong to. + * @return -1 if not set. + */ + int GetDllLoadInfoIndex(); + /** + * Note return value includes the set offset. + * So this value is not binary start - address. + * Instead it is. + * memory address - binary start address + offset + * @return adress + */ + unsigned long GetOffSetFromModuleStart(); + /** + * Get the binary start address + * @return binary start address + */ + unsigned long GetModuleStartAddress() const; + /** + * Set time + * @param ullTime + */ + void SetTime( unsigned long long& ullTime ); + /** + * Get time + * @return unsigned long long + */ + unsigned long long GetTime(); + /** + * Set address + * @param sAddess + */ + void SetAddress( string& sAddress ); + /** + * Get address string + * @return string + */ + string GetAddressString(); + /** + * Set address + * @param iAddress + */ + void SetAddress( unsigned long iAddress ); + /** + * Get Address + * @return unsigned long + */ + unsigned long GetAddress(); + /** + * Set module name + * @param sModuleName + */ + void SetModuleName( string& sModuleName ); + /** + * Get module name + * @return string + */ + string GetModuleName(); + /** + * Set state of locating code line + * @param eState + */ + void SetAddressToLineState( ADDRESS_TO_LINE_STATE eState ); + /** + * Get current state of locating code line + * @return int + */ + int GetAddressToLineState(); + /** + * Set filename + * @param sFileName + */ + void SetFileName(string& sFileName); + /** + * Get filename + * @return string + */ + string GetFileName(); + /** + * Set function name + * @param sFunctionName + */ + void SetFunctionName(string& sFunctionName); + /** + * Get function name + * @return string + */ + string GetFunctionName(); + /** + * Set function line number + * @param iFunctionLineNumber + */ + void SetFunctionLineNumber(int iFunctionLineNumber); + /** + * Get function line number + * @return int + */ + int GetFunctionLineNumber(); + /** + * Set exact line number + * @param iExactLineNumber + */ + void SetExactLineNumber(int iExactLineNumber); + /** + * Get exact line number + * @return int + */ + int GetExactLineNumber(); + /** + * Set module start address + * @param iAddress + */ + void SetModuleStartAddress(unsigned long iAddress); + +#ifndef MODULE_TEST +private: +#endif + // Used offset to add to addresses + unsigned long m_iOffSet; + // Address related members + string m_sAddress; + unsigned long m_iAddress; + + // Time (microseconds from 1970) + unsigned long long m_iTime; + + // Module related members(if FindSetModule is successful) + string m_sModuleName; + unsigned long m_iOffSetFromModuleStart; + unsigned long m_iModuleStartAddress; + + // Module to which address belong. + int m_iDllLoadinfoIndex; + + // Pin pointing related members + int m_ePinPointState; + string m_sFileName; + string m_sFunctionName; + + int m_iFunctionLineNumber; + int m_iExactLineNumber; +}; +#endif \ No newline at end of file diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/inc/CATMmp.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/inc/CATMmp.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,106 @@ +/* +* 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: Class responsible of handling mmp files. +* +*/ + + +#ifndef __CATMMP_H__ +#define __CATMMP_H__ + +// Includes +#include "ATCommonDefines.h" +#include "CATBase.h" + +/** +* CATMmp represents mmp file of module. +* All mmp file related actions are done using this class. +* @author +*/ +class CATMmp : public CATBase +{ + +public: + + // Constructor + CATMmp(); + + // Destructor + ~CATMmp(); + + string m_sMmpFile; /** The mmp file with path */ + + /** + * Makes AnalyzeTool changes to given mmp file. + * @param sTargetType target type of module i.e. exe / dll + * @param sId unique identification string added to source file name + * @return true if editing was successful. + */ + bool EditMmpFile(const string& sTargetType, const string& sId); + + /** + * Backups mmp file to atool_temp/file + * to path/atool_temp/filename.mmp.tmp. + * Calling this function results always to + * none edited mmp & none edited backup. + * @return true if successful. + */ + bool BackupMmpFile(); + + /** + * Restores backup from temporary directory (replacing current). + * @return true if successful. + */ + bool RestoreMmpFile(); + + /** + * VerifyAndRecover mmp file. + * Wont change mmp if it is not edited + * Replaces mmp file using backup if it exists and it is + * not edited otherwise removes changes from mmp file. + * @return true if successful + */ + bool VerifyAndRecover(); + +#ifndef MODULE_TEST +private: +#endif + /** + * Checks if the given mmp file is modified by AT + * @param bBackup if true checks backup + * @return bool true if it is edited + */ + bool IsMmpEdited(bool bBackup = false ); + + /** + * CreateBackupPath creates string containinig + * full path to backup mmp file + */ + string CreateMmpBackupPath(); + + /** + * Removes AnalyzeTool changes from given file + * @param bBackup if true removes changes from backup + * @return true if successfully removed changes + */ + bool RemoveMmpFileChanges(bool bBackup = false); + + /** + * Removes write protections from mmp file and its backup if exists. + * @return true if successful. + */ + bool RemoveWriteProtections(); + +}; +#endif \ No newline at end of file diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/inc/CATModule2.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/inc/CATModule2.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,545 @@ +/* +* 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: Class representing a module in project (sbs2). +* +*/ + + +#ifndef __CATMODULE2_H__ +#define __CATMODULE2_H__ + +// Includes. +#include "ATCommonDefines.h" +#include "CATBase.h" +#include "CATMmp.h" + +// Forward declarations. +class CATMemoryAddress; +class IAddressToLine; + +/** +* CATModule2 represents a module/component (single binary) in project. +* CATProject contains a collection of these. +*/ +class CATModule2 : public CATBase +{ + +public: + /** + * Constructor. + */ + CATModule2(void); + + /** + * Destructor. + */ + ~CATModule2(void); + + /** + * Read modules attributes from SBS v.1 makefile. + * Also copies makefile to temporary directory if successful. + */ + bool ReadMakeFile(); + + /** + * Read modules attributes from SBS v.1 makefile. + * From make file which is in modules temporary directory. + */ + bool ReadMakeFileFromTemp(); + + /** + * Add sources using line where source files separated by spaces. + * @param sSourceLine. + */ + void AddSources(string& sSourceLine); + + /** + * Add sources by giving source file and its corresponding listing file. + * @param sSourceFile + * @param sLstFile + */ + void AddSource(const string& sSourceFile, const string& sLstFile); + + /** + * Create AT temporary cpp file for module. + * @param sS60FileName. + * @param eLoggingMode. + * @param eBuildType. + * @param iAllocCallStackSize. + * @param iFreeCallStackSize. + * @return true if successful. + */ + bool CreateTempCpp(const string& sS60FileName + , int eLoggingMode + , int eBuildType + , int iAllocCallStackSize + , int iFreeCallStackSize ); + + /** + * Add AT changes to modules mmp file. + * @return true if successful. + */ + bool ModifyMmp(); + + /** + * Restore any changes made to modules mmp file. + * @return true if successful. + */ + bool RestoreMmp(); + + /** + * Verify tha mmp does not contain AnalyzeTool made changes. + * If it does contain them will remove them manually or using backup. + * @return true if successful. + */ + bool VerifyAndRecoverMmp(); + + /** + * Copy modules releasables to its temporary dir. + * This includes map & lst files. + * @return true if successful. + */ + bool CopyReleasables(); + + /** + * Copy modules listing files to given directory. + * After copy they will be deleted. + * @param sDir target directory. + * @return true if successful. + */ + bool CopyLstFilesToDir( const string& sDir ); + + /** + * Delete modules lst files from their source + * directories. + * @return true if succesfful. + */ + bool DeleteLstFilesFromSrc(); + + /** + * Clean modules temporary directory of files, + * not defined in UNDELETE list. + * @return true if successful + */ + bool CleanTemporaryDir(); + + /** + * Delete modules temporary directory. + * @return true if successful. + */ + bool DeleteTemporaryDir(); + + /** + * Locate codeline of given memory address. + * Given address must be calculated to correspond map file addresses. + * @param pMemoryAddress object where to store results. + * @return true if successful. + */ + bool AddressToLine(CATMemoryAddress* pMemoryAddress); + + /** + * Check does modules symbol file(s) exist. + * @return true if it exists. + */ + bool SymbolFileExist( void ); + + /** + * Check does modules map file(s) exists. + * @return true if it exists. + */ + bool MapFileExist( void ); + + /** + * Check does modules binary file(s) exist. + * @return true if it exists. + */ + bool BinaryFileExist( void ); + +#ifndef MODULE_TEST +private: +#endif + + /** + * Read modules attributes from make file. + */ + bool ReadMakeFilePrivate(); + + /** + * Locate codeline of given memory address (winscw platform). + * Given address must be calculated to correspond map file addresses. + * @param pMemoryAddress object where to store results. + * @return true if successful. + */ + bool AddressToLineWinscw(CATMemoryAddress* pMemoryAddress ); + + /** + * Locate codeline of given memory address (armv5 platform). + * Given address must be calculated to correspond map file addresses. + * @param pMemoryAddress object where to store results. + * @return true if successful. + */ + bool AddressToLineArmv5(CATMemoryAddress* pMemoryAddress ); + + /** + * Locate codeline of given memory address. + * Given address must be calculated to correspond map file addresses. + * @param pMemoryAddress object where to store results. + * @return true if successful. + */ + bool AddressToLineAddr2lineExe( CATMemoryAddress* pMemoryAddress ); + + /** + * Search map file data (symbols) using given address. + * @param iAddress memory address. + * @return index of the symbol or -1 if not found. + */ + int GetSymbolIndexUsingAddress(unsigned long iAddress) const; + + /** + * Search listing files data using the given symbol name. + * @param sSymbolName symbols name to find. + * @return index of the found lst data or -1 if not found. + */ + int GetLineInFileIndexUsingSymbolName(const string& sSymbolName) const; + + /** + * Search the exact code line from given file. + * @param sFileName listing file to search from. + * @param iLine functions line number. + * @param iFromFuncAddress how many bytes from functions start. + * @return line number or -1 if not found. + */ + int FindLeakCodeLine( string& sFileName, int iLine, unsigned long iFromFuncAddress ) const; + +public: + + /** + * Set used build system (CATProject::BUILD_SYSTEM). + * @param eBuildSystem. + */ + void SetBuildSystem( int eBuildSystem ); + + /** + * Get defined build system. + * @return int CATProject::BUILD_SYSTEM + */ + int GetBuildSystem( void ) const ; + + /** + * Set SBS v.1 makefile. + * @param sMakeFile + */ + void SetMakeFile( const string& sMakeFile ); + + /** + * Get SBS v.1 makefile. + * @return string makefile. + */ + string GetMakeFile( void ) const; + + /** + * Initialize module ready for locating code lines. + * with memory addresses (reads map and listing files). + * return true if successful. + */ + bool InitializeAddressToLine(); + + /** + * Set modules mmp file. + * This also creates temporary dir if it is missing. + * @return true if successful. + */ + bool SetMmpFile(const string& sMmpFile); + + /** + * Create modules own temporary directory. + * @return true if successful. + */ + bool CreateTemporaryDirectory(); + + /** + * Get modules mmp file. + * @return mmp file. + */ + string GetMmpFile() const; + + /** + * Get modules atool_temp directory path. + * @return atool_temp directory path. + */ + string GetTempPath() const; + + /** + * Get S60 logging file name. + * @return s60 logging file name. + */ + string GetS60FileName() const; + + /** + * Set target binary name. + * @param sTarget binary file name. + */ + void SetTarget(const string& sTarget); + + /** + * Get target binary name. + * @return modules binary file name. + */ + string GetTarget() const; + + /** + * Set binary target type. + * @param sTargetType binary target type. + */ + void SetTargetType(const string& sTargetType); + + /** + * Get binary target type. + * @return binary target type. + */ + string GetTargetType() const; + + /** + * Set requested binary target file extension. + * @param sRequestedTargetExt binary target file extension. + */ + void SetRequestedTargetExt( const string& sRequestedTargetExt ); + + /** + * Get requested binary target file extension. + * @return binary target file extension. + */ + string GetRequestedTargetExt() const; + + /** + * Get full name of modules binary. + * @return modules binary files full name. + */ + string GetBinaryName() const; + + /** + * Set variant platform. + * @param sVariantPlatform variant platform. + */ + void SetVariantPlatform(const string& sVariantPlatform); + + /** + * Get variant platform. + * @return variant platform. + */ + string GetVariantPlatform() const; + + /** + * Set variant type. + * @param sVariantType variant type. + */ + void SetVariantType(const string& sVariantType); + + /** + * Get variant type. + * @return variant type. + */ + string GetVariantType() const; + + /** + * Set feature variant. + * @param sFeatureVariant feature variant. + */ + void SetFeatureVariant(const string& sFeatureVariant); + + /** + * Get feature variant. + * @return feature variant. + */ + string GetFeatureVariant() const; + + /** + * Set feature variant name. + * @param sFeatureVariantName feature variant name. + */ + void SetFeatureVariantName(const string& sFeatureVariantName); + + /** + * Get feature variant name. + * @return feature variant name. + */ + string GetFeatureVariantName() const; + + /** + * Set release path. + * @param sReleasePath release path. + */ + void SetReleasePath(const string& sReleasePath); + + /** + * Get release path. + * @return release path. + */ + string GetReleasePath() const; + + /** + * Set full variant path. + * @param sFullVariantPath full variant path. + */ + void SetFullVariantPath(const string& sFullVariantPath); + + /** + * Get full variant path. + * @return full variant path. + */ + string GetFullVariantPath() const; + + /** + * Set compile definition(s) of the module. + * @param sCompileDefinitions + */ + void SetCompileDefinitions( const string& sCompileDefinitions ); + + /** + * Get compile definition(s) of the module. + * @return compile definition(s). + */ + string GetCompileDefinitions() const; + + /** + * Is modules target type udeb? + * @return true if modules target type is udeb. + */ + bool IsUDEB() const; + + /** + * Is module build successfully? + * This includes check of listing and map files from temporary directory. + * @return true if module build successfully. + */ + bool IsMakeSuccessfull(); + + /** + * Get error string. This includes possible erros what are generated when + * IsMakeSuccesfull is called. + * @return error string. + */ + string GetErrors() const; + + /** + * Create build complete file to modules temporary directory. + * @return true if build complete file created successfully. + */ + bool CreateBuildCompleteFile( void ); + + /** + * Read map file (armv5 platform). + * @return true if map file read successfully. + */ + bool ReadMapFileArmv5(); + + /** + * Set compile info text + * @param sCompileInfoText + */ + void SetCompileInfoText( string sCompileInfoText ); + + /** + * Get compile info text + * @return compile info text + */ + string GetCompileInfoText() const; + +#ifndef MODULE_TEST +private: +#endif + + /** + * Struct for saving source information + * sCpp is source file. + * sLst sources corresponding lst file. + * bStatic true if source information from static library. + */ + struct SOURCE + { + bool bStatic; + string sCpp; + string sLst; + SOURCE() : bStatic(false), sCpp(""), sLst("") {} + }; + + // Build system + int m_eBuildSystem; + // Sbs v.1 makefile + string m_sMakeFile; + // Mmp file. + CATMmp m_Mmp; + // Temporary directory with path. + string m_sTempPath; + // Target. + string m_sTarget; + // Target type. + string m_sTargetType; + // True target extension. + string m_sRequestedTargetExt; + // Variant platform. + string m_sVariantPlatform; + // Variant type. + string m_sVariantType; + // Feature variant. + string m_sFeatureVariant; + // Feature variant name. + string m_sFeatureVariantName; + // Release path (releasables). + string m_sReleasePath; + // Full variant path (path to releasables). + string m_sFullVariantPath; + // String to store information of compile + string m_sCompileInfoText; + // String to store possible error messages. + string m_sErrors; + // Compile definition(s) + string m_sCompileDefinitions; + // Source files. + vector m_vSources; + // Listing data. + vector m_vLineInFile; + // Modules map data (symbols). + vector m_vMapFileFuncList; + // File logging mode filename. + string m_sS60FileName; + // Is all data loaded for address to code line functions. + bool m_bAddressToLineInitialized; + // Read listing files (armv5 platform). + bool ReadListingFilesArmv5(); + // Get listing file name of given source file. + string GetLstNameOfSource(string sSource) const; + // Copy listing files to temporary directory. + bool CopyLstFilesToTemp(); + // Copy map file to temporary directory. + bool CopyMapFileToTemp(); + // Get full map file name. + string GetMapFile() const; + // Get full symbol file name. + string GetSymbolFile() const; + // Get full binary file name. + string GetBinaryFile() const; + // Helper function to check is platform armv5. + bool IsPlatformArmv5() const; + // Get "unique" id of module + string GetUniqueId() const; + // Sbs v.1 variant urel label. + string m_sFeatureVariantURELLabel; + // Sbs v.1 variant udeb label. + string m_sFeatureVariantUDEBLabel; + // Object used to get codelines of memory addresses. + IAddressToLine* m_pAddressToLine; +}; +#endif +//EOF diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/inc/CATParseTraceFile.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/inc/CATParseTraceFile.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,91 @@ +/* +* 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 class CATParseTrace, CProcessData and +* CSubTestData. +* +*/ + + +#ifndef __CATPARSETRACEFILE_H__ +#define __CATPARSETRACEFILE_H__ + +#include "../inc/ATCommonDefines.h" +#include "../inc/CATDataSaver.h" +#include "../inc/CATBase.h" +#include "../inc/catallocs.h" + +/** +* Parses raw trace data to AnalyzeTool specific data file. +*/ +class CATParseTraceFile : public CATBase +{ +public: + /** + * Constructor + */ + CATParseTraceFile(); + + /** + * Main function to start parse. + * + * @param pFileName A trace file name + * @param pOutputFileName Pointer to output file name + */ + bool StartParse( const char* pFileName, const char* pOutputFileName ); + + /** + * Get data saver + * @return CATDataSaver* + */ + CATDataSaver* GetDataSaver(void); + +#ifndef MODULE_TEST +private: +#endif + CATDataSaver m_DataSaver; /** Data saver */ +}; + +/** +* Represents data of a single subtest. +*/ +class CSubTestData : public CATAllocs +{ +public: + // Members + + bool bRunning; /** Is sub test running */ + vector vData; /** data */ + string sSubTestName; /** test name */ + string sStartTime; /** start time */ + string sEndTime; /** end time */ + string sSubTestStartHandleCount; /** handle count at start */ + string sSubTestEndHandleCount; /** handle count at end */ +}; + +/** +* Represents data of a single run. +*/ +class CProcessData : public CATAllocs +{ +public: + // Members + + bool bProcessOnGoing; /** is process on going */ + int iProcessID; /** process id (pid)*/ + vector vData; /** data */ + vector vHandleLeaks; /** handle leak(s) */ + vector vSubTests; /** process sub test(s) */ +}; + +#endif diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/inc/CATParseXML.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/inc/CATParseXML.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,46 @@ +/* +* 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: Declarations for the class CATParseXML. +* +*/ + + +#ifndef __CATPARSEXML_H__ +#define __CATPARSEXML_H__ + +#include "../inc/ATCommonDefines.h" + +/** +* CATParseXML is used to parse xml data. +*/ +class CATParseXML +{ +public: + /** + * Constructor + */ + CATParseXML(void); + + /** + * Destructor + */ + virtual ~CATParseXML(void); + + /** + * Find epocroot path in xml file + * @param sourcePath Location of the xml file + */ + string GetEpocRootPathFromXML(const char* sourcePath); +}; +#endif diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/inc/CATProject.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/inc/CATProject.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,629 @@ +/* +* 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: Class representing a project. +* +*/ + + +#ifndef __CATPROJECT_H__ +#define __CATPROJECT_H__ + +#include "ATCommonDefines.h" +#include "CATBase.h" + +class CATModule2; +class CATDatParser; + +// Raptor cmd and makefile constants used +#define RAPTOR_CMD_BASE "sbs -b bld.inf --makefile=atool_temp/build/make_build --config=" +#define RAPTOR_MAKEFILE "atool_temp\\build\\make_build.default" +#define RAPTOR_MAKEFILE_LOG " --logfile=atool_temp\\build\\makefile.xml" +#define RAPTOR_BUILD_LOG " --logfile=atool_temp\\build\\build.xml" +#define RAPTOR_REALLYCLEAN_LOG " --logfile=atool_temp\\build\\reallyclean.xml" +#define RAPTOR_BUILD_LOG_NAME "atool_temp\\build\\build.xml" +#define RAPTOR_LISTING_LOG " --logfile=atool_temp\\build\\listing.xml" + +#define RAPTOR_NOBUILD_SWITCH " --nobuild" +#define RAPTOR_MAKEFILE_SWITCH "--makefile=atool_temp/build/make_build" + + +// Raptor makefile constant variable names +#define RAPTOR_PROJECT_META "PROJECT_META:=" +#define RAPTOR_SOURCE "SOURCE:=" +#define RAPTOR_TARGET "TARGET:=" +#define RAPTOR_TARGETYPE "TARGETTYPE:=" +#define RAPTOR_REQUESTEDTARGETEXT "REQUESTEDTARGETEXT:=" +#define RAPTOR_VARIANTPLATFORM "VARIANTPLATFORM:=" +#define RAPTOR_VARIANTTYPE "VARIANTTYPE:=" +#define RAPTOR_FEATUREVARIANT "FEATUREVARIANT:=" +#define RAPTOR_FEATUREVARIANTNAME "FEATUREVARIANTNAME:=" +#define RAPTOR_RELEASEPATH "RELEASEPATH:=" +#define RAPTOR_FULLVARIANTPATH "FULLVARIANTPATH:=" +#define RAPTOR_COMPILE_DEFINITIONS "CDEFS:=" + +// Sbs v.1 makefile constants. +#define MAKEFILE_SEARCH_STRING "@perl -S checksource.pl" +#define MMPFILE_SEARCH_STRING "PRJ_MMPFILES MMP" +#define MMPTESTFILE_SEARCH_STRING "PRJ_TESTMMPFILES MMP" +#define SOURCE_PATH "SOURCEPATH" +#define SOURCE_STRING "SOURCE" +#define TARGET_STRING "TARGET" + +/** +* CATProject represents a project (collection of modules). +* It has to be set mode in which it operates like +* compile / analyze and necessary parameters for that. +* Then call Run method which also returs error codes +* defined in AT_ERROR_CODES enumeration. +* @author +*/ +class CATProject : public CATBase +{ +public: + + /** + * Enumeration representing used build systems + */ + enum BUILD_SYSTEM { + SBS_V1 = 1, + SBS_V2 = 2 + }; + + /** + * Enumeration representing the mode project is run. + */ + enum PROJECT_MODE { + COMPILE = 0, + INSTRUMENT = 1, + UNINSTRUMENT = 2, + UNINSTRUMENT_FAILED =3, + FAILED = 4, + CLEAN = 5, + ANALYZE = 6, + INSTRUMENT_CONSOLE = 7, + UNINSTRUMENT_CONSOLE = 8, + FAILED_CONSOLE = 9, + NOT_DEFINED = 10 + }; + + /** + * Enumeration repserenting the logging mode. + */ + enum LOGGING_MODE { + DEFAULT = 0, + FILE = 1, + TRACE = 2, + TRACE_FAST = 3 + }; + + /** + * Enumeration representing build type. + */ + enum BUILD_TYPE { + UREL = 0, + UDEB = 1 + }; + +public: + + /** + * Constructor + */ + CATProject(); + + /** + * Destructor + */ + ~CATProject(); + + /** + * Set arguments. + * @param arguments. + * @return true if arguments ok. + */ + bool SetArguments( ARGUMENTS& arguments ); + + /** + * Set build system to be used with project. + * See BUILD_SYSTEM enumeration for available systems. + * @param eSystem system. + */ + void SetBuildSystem( BUILD_SYSTEM eSystem ); + + /** + * Set mode which to run. + * See PROJECT_MODE enumeration for available modes. + * @param eMode mode. + */ + void SetMode(PROJECT_MODE eMode); + + /** + * Get project mode. + * @return mode of project. + */ + int GetMode() const; + + /** + * Set epocroot. + * @param sEpocroot + */ + void SetEpocRoot( const string& sEpocRoot ); + + /** + * Set project platform. + * @param sPlatform platform. + */ + void SetPlatform( const string& sPlatform ); + + /** + * Set variant. + * @sVariant variant. + */ + void SetVariant( const string& sVariant ); + + /** + * Set logging mode. See LOGGING_MODE enumeration for available modes. + * @param eLogginMode logging mode. + */ + void SetLoggingMode( LOGGING_MODE eLoggingMode); + + /** + * Set build type. See BUILD_TYPE enumeration for available types. + * @param eType build type. + */ + void SetBuildType( BUILD_TYPE eType ); + + /** + * Set S60 logging filename. + * @param sFileName filename. + */ + void SetS60FileName( const string& sFileName); + + /** + * Set target module. + * @param sTargetModule target module name. + */ + void SetTargetModule( const string& sTargetModule ); + + /** + * Set multiple target modules used in project. + * @param vTargetModules target module names. + */ + void SetTargetModules( const vector& vTargetModules ); + + /** + * Set Binary target name to create analysis results to. + * @param sBinaryTarget binary target name. + */ + void SetBinaryTarget( const string& sBinaryTarget ); + + /** + * Set data file to analyze. + * @param sDataFile datafile. + */ + void SetDataFile( const string& sDataFile ); + + /** + * Set rom symbol file(s) used in analyze. + * @param sRomSymbolFile. + */ + void SetRomSymbolFiles(const vector& vRomSymbolFiles); + + /** + * Set the logging level of analysis report. + * @param iLogLevel log level. + */ + void SetLogLevel( int iLogLevel ); + + /** + * Set the size of allocation call stack to be written in temporary cpp. + * @param iAllocCallStackSize + */ + void SetAllocCallStackSize( int iAllocCallStackSize ); + + /** + * Set the size of free call stack to be written in temporary cpp. + * @param iFreeCallStackSize + */ + void SetFreeCallStackSize( int iFreeCallStackSize ); + + /** + * Set the output file name to store analyse report. + * @param sDataFileOutput data file name. + */ + void SetDataFileOutput( const string& sDataFileOutput ); + + /** + * Set build command used in compile phase. + * @param sBuildCommand build command. + */ + void SetBuildCommand( const string& sBuildCommand ); + + /** + * Run the set mode. + * @return error code. + */ + int Run(); + + /** + * Run recovery, used when "instatly" need to recover modules and exit. + */ + int RunRecoveryAndExit(); + + /** + * Get build type string. + * @param eType type from which to get correponding string. + * @return types corresponding string. + */ + static string GetBuildTypeString( int eType ); + + /** + * Reads projects configuration file if it exists. + * @return false in case the data contains information that project is uninstrumented. Otherwise returns always true. + */ + bool IsUninstrumented(); + +#ifndef MODULE_TEST +private: +#endif + /** + * Run compiling in console. + * @return error code. + */ + int RunCompile( void ); + + /** + * Run cleaning project. + * @return error code. + */ + int RunClean( void ); + + /** + * Run running analyze. + * @return error code. + */ + int RunAnalyze( void ); + + /** + * Run instrumenting of project for Carbide extension (pre-build). + * @return error code. + */ + int RunInstrument( void ); + + /** + * Run uninstrumenting of project for Carbide extension (post-build). + * @return error code. + */ + int RunUninstrument( void ); + + /** + * Run uninstrumenting of project for Carbide extension(post-build), when build failed. + * @return error code. + */ + int RunUninstrumentFailed( void ); + + /** + * Run console instrumenting. + * @return error code. + */ + int RunInstrumentConsole( void ); + + /** + * Run Console uninstrumenting. + * @return error code. + */ + int RunUninstrumentConsole( void ); + + /** + * Run console uninstrumenting, when build failed. + * @return error code. + */ + int RunFailedConsole( void ); + + /** + * Show summary of compilation. + */ + void DisplayCompileSummary( void ); + + /** + * Show summary, build target, build type, logging mode... + */ + void DisplayBuildSummary( void ); + + /** + * Create make files. + * @return true if successful + */ + bool CreateMakeFile( void ); + /** + * Create SBS v.1 make files. + * @return true if successful. + */ + bool CreateMakeFileSbs1( void ); + /** + * Copy sbs1 makefile to temporary folder. + * @return true if successful. + */ + bool CopyMakeFileSbs1ToTemporaryFolder( void ); + /** + * Run really clean in SBS v.1. + * @return true if successful. + */ + bool RunReallyCleanSbs1( void ); + /** + * Run really clean in SBS v.2. + * @return true if successful. + */ + bool RunReallyCleanSbs2( void ); + /** + * Run export in SBS v.1. + * @return true if successful. + */ + bool RunExportSbs1( void ); + /** + * Create make files (level2) SBS v.1. + * @return true if successful. + */ + bool CreateMakeFileSbs1Level2( void ); + /** + * Create makefile SBS v.2. + * @return true if successful. + */ + bool CreateMakeFileSbs2( void ); + /** + * Read makefile. + * @return true if successful. + */ + bool ReadMakeFile( void ); + /** + * Read SBS v.1 makefile. + * @return true if successful. + */ + bool ReadMakeFileSbs1( void ); + /** + * Read SBS v.1 makefile (Level1). + * @return true if successful. + */ + bool ReadMakeFileSbs1Level1( void ); + /** + * Read SBS v.2 makefiles. + * @return true if successful. + */ + bool ReadMakeFileSbs2( void ); + /** + * Read specified SBS v.2 makefile. + * @param sMakeFile makefile to be read. + * @return true if succesful. + */ + bool ReadMakeFileSbs2( string& sMakeFile ); + + /** + * Filter unsupported and static libraries to their own vectors. + * Unsupported include kernel types, modules with kernel mode compile definition. + * @return true if successful. + */ + bool FilterModules(); + + /** + * Creates temporary directories for all modules + * in member vector. + * @return true if successful. + */ + bool CreateTemporaryDirectories(); + + /** + * Creates tempororary cpp files for all modules + * in member vector. + * @return true if successful. + */ + bool CreateTemporaryCpps(); + + /** + * Hooks all modules in member vector + * (modifies mmp files) + * @return true if successful + */ + bool ModifyModules( void ); + + /** + * Unhooks all modules in member vector + * (removes changes from mmp files) + * @return true if successful + */ + bool RestoreModules( void ); + + /** + * Verifys that member vectors modules + * mmp files unchanged. Restores if they are + * from backup or from original. + * @return true if successful + */ + bool VerifyAndRecoverModules( void ); + + /** + * Runs compilation. + * @return true if successful. + */ + bool Compile( void ); + /** + * @return true if successful. + */ + bool CompileSbs1( void ); + /** + * @return true if successful. + */ + bool CompileSbs2( void ); + + /** + * Runs listing creatation. + * @return true if successful + */ + bool CreateListings( void ); + /** + * @return true if successful. + */ + bool CreateListingsSbs1( void ); + /** + * @return true if successful. + */ + bool CreateListingsSbs2( void ); + /** + * Copies releasables of modules including lst & map files + * for all modules in project to their temporary directories. + * @return true if successful. + */ + bool CopyReleasables( void ); + /** + * Deletes all atool_temp directories + * of member vector modules. + * @return true if successful. + */ + bool DeleteTemporaryDirs( void ); + /** + * Deletes files from atool_temp directory + * of member vector modules which extension not defined + * in TEMP_EXTENSION_NO_DELETE table. + * @return true if successful. + */ + bool CleanTemporaryDirs( void ); + /** + * Writes class attributes to a file + * under atool_temp directory. + * @return true if successful. + */ + bool WriteAttributes( void ) const; + /** + * Read class attributes from a file + * under atool_temp directory. + * @return true if successful. + */ + bool ReadAttributes( void ); + + /** + * Creates atool_temp directory if it does not + * exist in current directory. + * @return true if successful. + */ + bool MakeTempDirIfNotExist( void ); + +#ifndef MODULE_TEST +private: +#endif + + /** + * Clean all module vectors. + */ + void CleanModuleVectors(); + + /** + * Get build type as string. + * @return buildtype string. + */ + string GetBuildTypeString(); + + /** + * Helper function to add target module(s) + * if any defined in class to given sbs command. + * @param sCmd command to add modules to. + */ + void AddTargetModuleIfDefined(string& sCmd); + + /** + * Run given system/abld command to all defined target modules in vector. + * Space char (if its missing) will be added to given command + one target + * module at a time. + * @param sCommand sCommand to run. + * @return true if none system call sets error level other than 0. + */ + bool RunAbldCommandToAllTargets( const string& sCommand ); + + /** + * Check is target module in project. + * If no modules / targets defined return value is true. + * @return true if target module is in project. + */ + bool IsTargetModuleInProject( void ) const; + + /** + * Initializes member make file variable with correct full path to point (epoc32/build)... + * @return true if successful. + */ + bool InitSbs1MakeFileWithPath(); + + /** + * Initializes member make file variable with correct full path to (atoo_temp...) + * @return true if successful. + */ + bool InitSbs1MakeFileWithPathToTemp(); + +#ifndef MODULE_TEST +private: +#endif + // System current directory. + char m_cCurrentDir[ MAX_LINE_LENGTH ]; + // Projects build system + int m_eBuildSystem; + // Project modules. + vector m_vModules; + // Static libraries. + vector m_vStaticLibraries; + // Unsupported project modules. + vector m_vUnsupportedModules; + // Run mode. + int m_eMode; + // Logging level (used in analyse). + int m_iLoggingLevel; + // Is project unsinstrumented. + bool m_bUninstrumented; + // Is build just for test modules + bool m_bAbldTest; + // Build command. + string m_sBuildCommand; + // Epocroot + string m_sEpocRoot; + // Platform i.e. armv5. + string m_sPlatform; + // SBS2 variant. + string m_sVariant; + // Logging mode (used in compile,instrumenting). + int m_eLoggingMode; + // Allocation call stack size + int m_iAllocCallStackSize; + // Free call stack size + int m_iFreeCallStackSize; + // Build type udeb / urel. + int m_eBuildType; + // Sbs v.1 level 1 make file + string m_sMakeFile; + // User given S60 log file name. + string m_sS60FileName; + // Target module. + string m_sTargetModule; + // Target modules (used in carbide instrumenting). + vector m_vTargetModules; + // Binary target (used in analyse). + string m_sBinaryTarget; + // User given datafile to analyse. + string m_sDataFile; + // + vector m_vRomSymbolFiles; + // Temporary data file name if user gave trace file. + string m_sDataFileTemp; + // User given output file to store analyse results. + string m_sDataFileOutput; + // Analyser object. + CATDatParser* m_pAnalyzer; +}; +#endif +// End of file diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/inc/cataddr2line.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/inc/cataddr2line.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,130 @@ +/* +* 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: Windows debug api implementation for IAddressToLine interface. +* +*/ + +#ifndef __CATADDR2LINE_H__ +#define __CATADDR2LINE_H__ + +#include "iaddresstoline.h" +#include "../inc/cataddr2lineserver.h" + +// Allowed characters in output. +//const char ADDR2LINEALLOWEDCHARS[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 :/\\_.-"; + +/** +* Implements addresstoline interface using one of the GNU binutils tool called addr2line. +* This is used on gcce platform. In release build type also map files are used. +*/ +class CATAddr2line : public IAddressToLine +{ + +public: + + /** + * Constructor + */ + CATAddr2line(); + + /** + * Open binary. + * @sString Full filename with path to binary. + * @iLong base address of binary. + * @return true if successful. + */ + bool Open( const string& sString, const unsigned long iLong); + + /** + * Get error string. In case of any method failed use this to acquire details on error. + * @return error string. + */ + string GetError( void ); + + /** + * Close binary. + * @return true if succesful. + */ + bool Close( void ); + + /** + * Locate code line and file for given address. + * @result + * @return true if successful. + */ + bool AddressToLine( CATMemoryAddress* result ); + +#ifndef MODULE_TEST +private: +#endif + + // Modules map data (symbols). + vector m_vMapFileFuncList; + + //Map file name + string m_sMapFileName; + + //Addr2line server class + CATAddr2lineServer server; + + /** + * Get function name for given address. + * @iAddress Memory address as unsigned long. + * @return Function name as string or empty string if not found. + */ + string GetFunctionNameUsingAddress( unsigned long iAddress ); + + /** + * Read map file (armv5 platform). + * @return true if map file read successfully. + */ + bool ReadMapFileArmv5(); + + //Note: New filtering functions commented out until they are taken into use. + //These were part of task which would filter unwanted characters, etc.. from results. + + /** + * Filter any char not defined in constant + * ADDR2LINEALLOWEDCHARS from given string. + * @param sString string to be filtered. + */ + //void FilterString( string &sString ); + + /** + * Find first occurence of LF/CR from string. + * @param sString string to find LF/CR. + * @return position of first occurence. + */ + //size_t FindLineFeed( const string& sString ); + + /** + * Erase all LF/CR from start of the string until other + * characters are found. + * @param sString string to erase LF/CR. + */ + //void EraseUntilNoLineFeed( string& sString ); + + /** + * Split string containing multiple lines with mixed line feeds to + * vector of lines. + * @sMultiLineString string containing multiple lines. + * @return vector containing one line per cell. + */ + //vector SplitToStrings( string& sMultiLineString ); + + //Debugging for addr2line task. + //ofstream debug; +}; + +#endif diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/inc/cataddr2lineserver.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/inc/cataddr2lineserver.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,93 @@ +/* +* 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: Defines CATAddr2lineServer class. +* +*/ + +#ifndef __CATADDR2LINESERVER_H__ +#define __CATADDR2LINESERVER_H__ + +// Includes. +#include "ATCommonDefines.h" + +#define BUFSIZE 4096 + +/** +* This class "runs" the addr2line binary as a server for CATAddr2Line. +* It redirects the pipes from the tool. +*/ +class CATAddr2lineServer +{ +public: + + //Creator + CATAddr2lineServer(); + + //Destructor + ~CATAddr2lineServer(); + + /** + * Get function name for given address. + * @sFullPathAndBinaryName + * @return True if initialization succesfull. + */ + bool Initialize( const string& sFullPathAndBinaryName ); + + /** + * Write data to a pipe. + * @sAddress + */ + VOID WriteToPipe( const string& sAddress ); + + /** + * Read data to a pipe. + * @return Data from pipe. + */ + string ReadFromPipe(VOID); + + /** + * Gets process created state. + * @return True if process created successfully. + */ + bool GetProcessCreatedState( void ); + +#ifndef MODULE_TEST +private: +#endif + + HANDLE m_hChildStdinRd, m_hChildStdinWr, m_hChildStdinWrDup, + m_hChildStdoutRd, m_hChildStdoutWr, m_hChildStdoutRdDup, + m_hChildErroutRd, m_hChildErroutWr, m_hChildErroutRdDup, + m_hSaveStdin, m_hSaveStdout, m_hSaveErrout; + + SECURITY_ATTRIBUTES m_saAttr; + string m_sFullPathAndBinaryName; + bool m_bProcessCreated; + + /** + * Creates child process for addr2line.exe. + * @return True if process created successfully. + */ + BOOL CreateChildProcess(VOID); + + /** + * Prints error and returns false. + * @param sInput error string. + * @return false. + */ + bool PrintErrorAndExit( const string sInput ); + + +}; +#endif diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/inc/catalloc.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/inc/catalloc.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,59 @@ +/* +* 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: Defines CATAlloc class. +* +*/ + + +#ifndef __CATALLOC_H__ +#define __CATALLOC_H__ + +#include "../inc/ATCommonDefines.h" + +/** +* Class representing single memory allocation. +*/ +class CATAlloc +{ +public: + /** + * Constructor. + */ + CATAlloc() : m_iCSCount(0) {} + + /** + * Destructor. + */ + ~CATAlloc(){} + + /** + * Get alloc string after address, it contains: + * time, size, call stack.. + * @return string allocation string + */ + string GetAllocString(); + + // Members + + string m_sTime; /** Allocation time */ + + string m_sSize; /** Allocation size */ + + unsigned long m_iCSCount; /** Call stack address count */ + + map m_vCallStack; /** Call stack where packet number is key */ + +}; +#endif +//EOF diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/inc/catallocs.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/inc/catallocs.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,87 @@ +/* +* 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: Defines CATAllocs "collection" class. +*/ + +#ifndef __CATALLOCS_H__ +#define __CATALLOCS_H__ + +#include "../inc/ATCommonDefines.h" +#include "../inc/CATBase.h" +#include "../inc/catalloc.h" + +/** +* Class representing a collection of memory allocations. +* It is used to acquire the data of memory leaks by giving all +* data on single allocations and frees. +*/ +class CATAllocs : public CATBase +{ +public: + + /** + * "old" alloc message (prior to 1.6). + * @param sAllocString allocation string + */ + void Alloc( const string& sAllocString ); + + /* + * Alloc header message (multimessage call stack). + * @param sAllocHString allocation string + */ + void AllocH( const string& sAllocHString ); + + /* + * Alloc fragment message (fragment of call stack in multimessage alloc). + * @param sAllocFString allocation string + */ + void AllocF( const string& sAllocFString ); + + /** + * Free message. + * @param sFreeString string + */ + void Free( const string& sFreeString ); + + /** + * Free header message. + * (not implemented yeat.) + * @param sFreeHString string + */ + void FreeH( const string& sFreeHString ); + + /** + * Free fragment message. + * (not implemented yeat.) + * @param sFreeFString string + */ + void FreeF( const string& sFreeFString ); + + /** + * Get "leak" list ordered by allocation time. + * @param vLeakList container where leaks stored + */ + void GetLeakList( vector& vLeakList); + + /** + * Clear leaks. + */ + void ClearAllocs(); +#ifndef MODULE_TEST +private: +#endif + map m_vAllocs; /** Collection of allocation(s) */ +}; +#endif +//EOF diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/inc/catdbghelper.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/inc/catdbghelper.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,97 @@ +/* +* 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: Defines the CATDbgHelper class. +* +*/ + + +#include "iaddresstoline.h" +// Static variable to represent state of dbghelper api. +static bool CDBGHELPER_OPEN = false; +static unsigned int CDBGHELPER_CLIENTS = 0; + +// Used "virtual" offset for all loaded modules and addresses. +// This is used so no module is loaded to the binary address range of atool.exe. +const unsigned long AT_VIRTUAL_OFFSET_DBGHELPER = 0x1000000; + +/** +* Provides feature to locate code lines using Windows Debug Api. This is done +* by using dbghelper library. Implements the IAddressToLine interface. +*/ +class CATDbgHelper : public IAddressToLine +{ + +public: + + /** + * Constructor + */ + CATDbgHelper(); + + /** + * Destructor + */ + ~CATDbgHelper(); + + /** + * Open binary. + * @sString Full filename with path to binary. + * @iLong base address of binary. + * @return true if successful. + */ + bool Open( const string& sString, const unsigned long iLong); + + /** + * Get error string. In case of any method failed use this to acquire details on error. + * @return error string. + */ + string GetError( void ); + + /** + * Close binary. + * @return true if succesful. + */ + bool Close( void ); + + /** + * Read map file for function's. + */ + void ReadMapFile( const string sMapFileName ); + + /** + * Locate code line and file for given address. + * @result + * @return true if successful. + */ + bool AddressToLine( CATMemoryAddress* result ); + + /** + * Try get function name for address (only when map is read). + * @result + * @return true if succesful. + */ + bool AddressToFunction( CATMemoryAddress* result ); + +#ifndef MODULE_TEST +private: +#endif + // Base address used. + DWORD64 m_BaseAddress; + // Map file read? + bool m_bMap; + // Map file functions. + vector m_vMapFileFuncList; + // Binary in file system. + PSTR m_pBinaryFile; +}; \ No newline at end of file diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/inc/catfilereader.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/inc/catfilereader.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,86 @@ +/* +* 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: Defines CATFileReader class. +* +*/ + + +#ifndef __CATFILEREADER_H__ +#define __CATFILEREADER_H__ + +#include "ATCommonDefines.h" + +/** +* Provides a feature to read a file as single block into memory and parse it +* from there line by line (iterating). This can fail or be very slow if file +* size is bigger than available physical memory for process. +* But is faster when file fits in free physical memory. +*/ +class CATFileReader +{ +public: + /** + * Constructor. + */ + CATFileReader(); + /** + * Destructor. + */ + ~CATFileReader(); +#ifndef MODULE_TEST +private: +#endif + /** + * Prevent copy of this class. + */ + CATFileReader& operator =( const CATFileReader& /*other*/ ) { } + CATFileReader( const CATFileReader& /*other*/ ) { } +public: + /** + * Open/Read file. + * @param cFile file to be read/opened. + * @return true if succesful. + */ + bool Open( const char* cFile ); + /** + * Close file. + * @return true if succesful. + */ + bool Close( void ); + /** + * Get line from file. + * @sLine where line content is stored. + * @return true if lines left. + */ + bool GetLine( string& sLine ); + /** + * Set the line delimiter. + * @param cDelimiter char that ends the line. + */ + void SetDelimiter( char cDelimiter ); + /** + * Get current line delimiter. + * @return char that ends the line. + */ + char GetDelimiter() const; +#ifndef MODULE_TEST +private: +#endif + // Stream where file content is stored. + stringstream m_stream; + // Line delimiting character used. + char m_cDelimiter; +}; +#endif +// EOF diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/inc/catromsymbol.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/inc/catromsymbol.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,196 @@ +/* +* 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: Defines CATRomSymbol, RofsBinary classes and Symbol +* structure. +* +*/ + + +#ifndef __CATROMSYMBOL_H__ +#define __CATROMSYMBOL_H__ + +#include "ATCommonDefines.h" +#include "iaddresstoline.h" + +const string ROM_SYMBOL_IDENTIFY_STRING = "80"; +const string ROFS_SYMBOL_IDENTIFY_STRING = "00"; +const int IDENTIFY_MAX_LINES_READ = 20; + +/** +* Represents a single symbol in a binary. +*/ +struct Symbol +{ + unsigned long iStartAddress; /** Start address */ + unsigned long iEndAddress; /** End address */ + string sFunction; /** Function/Symbol name */ + /** + * Default constructor for structure to set default values + */ + Symbol() { iStartAddress=0; iEndAddress=0; sFunction = ""; } + /** + * Empty destructor + */ + ~Symbol() {} +}; + + +/** +* Represents a single binary in ROM/ROFS which +* contains a collection of Symbols. +*/ +class RofsBinary { +public: + /** + * Constructor + */ + RofsBinary(); + /** + * Constructor + * @param sbinary + */ + RofsBinary( const string& sbinary ); + /** + * Destructor + */ + ~RofsBinary(); + + // Members + + string m_sBinary; /** Binary / code segment */ + vector vSymbols; /** Collection of symbols */ +}; + +/** +* Implements IAddressToLine interface to acquire symbol information +* using memory addresses from rom/rofs symbol files. +*/ +class CATRomSymbol : public IAddressToLine +{ +public: + /** + * Constructor. + */ + CATRomSymbol(); + /** + * Destructor. + */ + virtual ~CATRomSymbol(); + bool m_bShowProgressMessages; /** "Flag" will we show progress when reading files */ + /** + * Empty functions does nothing returns false always. + * @param sString + * @param iLong + * @return true if successful. + */ + bool Open( const string& sString, const unsigned long iLong); + /** + * Set symbol files. + * This also checks that files exists and identifies them as rom/rofs. + * @param vSymbols + * @return bool + */ + bool SetSymbols( const vector& vSymbols); + /** + * Get error string. In case of any method failed use this to acquire details on error. + * @return error string. + */ + string GetError( void ); + /** + * Close rom symbol file. + * @return true if succesful. + */ + bool Close( void ); + /** + * Locates symbol and binary name for given address if found in rom. + * @param result memory address object. + * @return true if successful. + */ + bool AddressToLine( CATMemoryAddress* result ); +#ifndef MODULE_TEST +private: +#endif + /** + * Represents the symbol files type + * (content is different / format ) + */ + enum SYMBOL_FILE_TYPE { + SYMBOL_FILE_INVALID = 0, /** not valid */ + SYMBOL_FILE_ROM, /** rom type */ + SYMBOL_FILE_ROFS /** rofs type */ + }; + /** + * Identify symbol file + * @param sFile + * @return int + */ + int IdentifySymbolFile( const string& sFile ); + /** + * Locate symbol and binary name for given address if found in rom. + * @param result + * @return bool + */ + bool AddressToLineRom( CATMemoryAddress* result ); + /** + * Locate symbol and binary name for given address if found in rofs. + * @param result + * @return bool + */ + bool AddressToLineRofs( CATMemoryAddress* result ); + /** + * Reads rom files. + * @return bool + */ + bool ReadRomFiles(); + /** + * Read specified rom file + * @param sFile + * @return bool + */ + bool ReadRomFile( const string& sFile ); + /** + * Read rofs files + * @return bool + */ + bool ReadRofsFiles(); + /** + * Read specified rofs file + * @param sFile + * @return bool + */ + bool ReadRofsFile( const string& sFile ); + /** + * Parse symbol from a line in rom/rofs file. + * @param sLine + * @param pSymbol + */ + void ParseSymbolFromLine( const string& sLine, Symbol* pSymbol ); +#ifndef MODULE_TEST +private: +#endif + + // Members + + bool m_bFilesIdentified; /** Have we identified symbol file(s) */ + bool m_bSymbolsRead; /** Have we read symbol file(s) */ + vector m_vRomFiles; /** Rom symbol file(s) */ + vector m_vRomCache; /** Cached rom symbols */ + vector m_vRomSymbols; /** All rom symbols */ + unsigned long m_iRomStartAddress; /** Rom start address */ + unsigned long m_iRomEndAddress; /** Rom end address */ + vector m_vRofsFiles; /** Rofs symbol file(s) */ + vector m_vRofsBinaries; /** Rofs binaries */ + string m_sErrorMessage; /** Error message */ +}; +#endif \ No newline at end of file diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/inc/iaddresstoline.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/inc/iaddresstoline.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,60 @@ +/* +* 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: Interface definition for locating code lines using memory addresses. +* +*/ +#ifndef __IADDRESSTOLINE_H__ +#define __IADDRESSTOLINE_H__ + +#include "ATCommonDefines.h" + +class CATMemoryAddress; + +/** +* Codeline locating interface. Thru this interface CATModule2 locates code lines +* using different implementations depending on platform. +*/ +class IAddressToLine +{ +public: + IAddressToLine() {}; + virtual ~IAddressToLine() {}; + /** + * Open binary. + * @sString + * @iNumber + * @return true if successful. + */ + virtual bool Open( const string& sString, const unsigned long iLong) = 0; + + /** + * Get error string. In case of any method failed use this to acquire details on error. + * @return error string. + */ + virtual string GetError( void ) = 0; + + /** + * Close binary. + * @return true if succesful. + */ + virtual bool Close( void ) = 0; + + /** + * Locate code line and file for given address. + * @result + * @return true if successful. + */ + virtual bool AddressToLine( CATMemoryAddress* result ) = 0; +}; +#endif \ No newline at end of file diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/inc/stdafx.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/inc/stdafx.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,45 @@ +/* +* Copyright (c) 2008 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: Include file for standard system include files, +* or project specific include files that are used frequently, but +* are changed infrequently. +*� Version�� : %version: 1 % +* +*/ + + +#pragma once + +// MemoryLeak checking function. +// Note! Do not comming in svn with this flag enabled. +//#define MEM_LEAK_CHECK + +// Addr2line binary used. +//#define ADDR2LINE + +#ifdef MEM_LEAK_CHECK +#define _CRTDBG_MAP_ALLOC +#include +#include +#endif + +#include +#include //ifstream,ofstream +#include +#include //string +#include //string +#include //stringstream +#include // cout +#include // map +#include \ No newline at end of file diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/install/addr2line.exe Binary file analyzetool/commandlineengine/install/addr2line.exe has changed diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/install/atool.exe Binary file analyzetool/commandlineengine/install/atool.exe has changed diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/install/binutils-2.19.1-src.zip Binary file analyzetool/commandlineengine/install/binutils-2.19.1-src.zip has changed diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/install/xerces-c_2_7.dll Binary file analyzetool/commandlineengine/install/xerces-c_2_7.dll has changed diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/lib/xerces-c_2.lib Binary file analyzetool/commandlineengine/lib/xerces-c_2.lib has changed diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/src/CATBase.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/src/CATBase.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,1299 @@ +/* +* 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 CATBase. +* +*/ + + +#include "../inc/CATBase.h" +#include "../inc/CATParseXML.h" + +// ----------------------------------------------------------------------------- +// CATBase::CATBase +// Constructor. +// ----------------------------------------------------------------------------- +CATBase::CATBase(void) +{ + LOG_FUNC_ENTRY("CATBase::CATBase"); +} + +// ----------------------------------------------------------------------------- +// CATBase::~CATBase +// Destructor. +// ----------------------------------------------------------------------------- +CATBase::~CATBase(void) +{ + LOG_FUNC_ENTRY("CATBase::~CATBase"); +} + +// ----------------------------------------------------------------------------- +// CATBase::ChangeToLower +// Converts any uppercase letter to lowercase. +// ----------------------------------------------------------------------------- +void CATBase::ChangeToLower( string& sInput ) +{ + LOG_LOW_FUNC_ENTRY("CATBase::ChangeToLower"); + int iLength = (int)sInput.size(); + for( int i = 0 ; i < iLength ; i++ ) + { + sInput[i] = (char)tolower( sInput[i] ); + } +} + +// ----------------------------------------------------------------------------- +// CATBase::ChangeToUpper +// Converts any uppercase letter to lowercase. +// ----------------------------------------------------------------------------- +void CATBase::ChangeToUpper( string& sInput ) +{ + LOG_LOW_FUNC_ENTRY("CATBase::ChangeToUpper"); + int iLength = (int)sInput.size(); + for( int i = 0 ; i < iLength ; i++ ) + { + sInput[i] = (char)toupper( sInput[i] ); + } +} + +// ----------------------------------------------------------------------------- +// CATBase::TrimString +// Remove spaces and tabulatures from beginning and +// end of given string. +// ----------------------------------------------------------------------------- +void CATBase::TrimString( string& sInput ) +{ + LOG_LOW_FUNC_ENTRY("CATBase::TrimString"); + if( sInput.empty() ) + return; + //Remove spaces and tabulatures from beginning of string + while( !sInput.empty() && ( sInput[0] == SPACE_CHAR_VALUE || sInput[0] == TAB_CHAR_VALUE ) ) + { + sInput.erase( 0, 1 ); + } + //Remove spaces and tabulatures from end of string + while( !sInput.empty() && ( sInput[sInput.size()-1] == SPACE_CHAR_VALUE || sInput[sInput.size()-1] == TAB_CHAR_VALUE ) ) + { + sInput.erase( sInput.size()-1, 1 ); + } +} + +// ----------------------------------------------------------------------------- +// CATBase::SearchFileWithExtension +// Searches files with given extension from path. +// ----------------------------------------------------------------------------- +bool CATBase::SearchFileWithExtension( const char* pPathAndExt, bool bPrintErrors, string& sErrorLog ) +{ + LOG_FUNC_ENTRY("CATBase::SearchFileWithExtension"); + WIN32_FIND_DATA FindFileData; + HANDLE hFind; + string sTemp( pPathAndExt ); + + //Find file + hFind = FindFirstFile( sTemp.c_str(), &FindFileData ); + if (hFind == INVALID_HANDLE_VALUE) + { + string sErrorString( "No " ); + //Get extension + string sExt( pPathAndExt ); + sExt.erase( 0, sExt.find_last_of( "." ) ); + + sErrorString.append( sExt ); + sErrorString.append( " files in directory: " ); + + string sWithoutExt( pPathAndExt ); + sWithoutExt.erase( sWithoutExt.find_last_of( "." )-1, string::npos ); + sErrorString.append( sWithoutExt ); + + if( bPrintErrors ) + { + //string sTemp( pPathAndExt ); + //printf( "Can not find: %s.\n", pPathAndExt ); + printf( sErrorString.c_str() ); + } + else + { + //Add line change if sErrorString not empty + if( !sErrorLog.empty() ) + sErrorString.insert( 0, "\n" ); + sErrorLog.append( sErrorString ); + } + return false; + } + else + { + FindClose(hFind); + return true; + } +} + +// ----------------------------------------------------------------------------- +// CATBase::GetPathOrFileName +// Returns path to file or file name. +// ----------------------------------------------------------------------------- +string CATBase::GetPathOrFileName( bool bFileName, string sInput ) +{ + LOG_LOW_FUNC_ENTRY("CATBase::GetPathOrFileName"); + string sRet; + size_t iPos = sInput.size(); + + sInput = ChangeSlashToBackSlash( sInput ); + + //Find character '\' starting from end of string + while( iPos > 0 && sInput[iPos] != '\\' ) + { + iPos--; + } + if( iPos > 0 ) + { + //Return file name + if( bFileName ) + { + sInput.erase( 0, iPos+1 ); + sRet = sInput; + } + else //Return file path + { + sInput.erase( iPos+1, string::npos ); + sRet = sInput; + } + } + else + { + if( !bFileName ) + return sRet; + sRet = sInput; + } + return sRet; +} + +// ----------------------------------------------------------------------------- +// CATBase::GetFileNameUsingExt +// Searches files with given extension from path. +// ----------------------------------------------------------------------------- +string CATBase::GetFileNameUsingExt( const char* pPathAndExt ) +{ + LOG_FUNC_ENTRY("CATBase::GetFileNameUsingExt"); + WIN32_FIND_DATA FindFileData; + HANDLE hFind; + string sRet; + + //Find file + hFind = FindFirstFile( pPathAndExt, &FindFileData ); + if (hFind == INVALID_HANDLE_VALUE) + { + //if( bPrintErrors ) + printf( "Can not find: %s.\n", pPathAndExt ); + return sRet; + } + else + { + sRet.append( FindFileData.cFileName ); + FindClose(hFind); + return sRet; + } +} + +// ----------------------------------------------------------------------------- +// CATBase::GetStringUntilNextSpace +// Function returns string from begin of given string until next space, +// characters until next space are removed from sInput string. +// ----------------------------------------------------------------------------- +string CATBase::GetStringUntilNextSpace( string& sInput, bool bEraseFromInput ) +{ + LOG_LOW_FUNC_ENTRY("CATBase::GetStringUntilNextSpace"); + string sTemp( sInput ); + size_t iSize = sTemp.find_first_of(' '); + if( iSize != string::npos ) + { + sTemp.resize( iSize ); + if( bEraseFromInput ) + sInput.erase( 0, (iSize+1) ); + } + else + { + if ( bEraseFromInput ) + sInput.clear(); + } + return sTemp; +} + +// ----------------------------------------------------------------------------- +// CATBase::ChangeSlashToBackSlash +// Function changes all BackSlash characters to Slash character from +// given string. +// ----------------------------------------------------------------------------- +string CATBase::ChangeSlashToBackSlash( string sInput ) +{ + LOG_LOW_FUNC_ENTRY("CATBase::ChangeSlashToBackSlash"); + for( unsigned int i = 0 ; i < sInput.length() ; i++ ) + { + if( sInput[i] == '/' ) + { + sInput[i] = '\\'; + } + } + return sInput; +} + +// ----------------------------------------------------------------------------- +// CATBase::FileExists +// Check if given file exists. +// ----------------------------------------------------------------------------- +bool CATBase::FileExists( const char * pFilename ) +{ + LOG_FUNC_ENTRY("CATBase::FileExists"); + DWORD dwRet = GetFileAttributes( pFilename ); + if( dwRet == INVALID_FILE_ATTRIBUTES ) + { + return false; + } + else + { + //Is file directory? + if( dwRet & FILE_ATTRIBUTE_DIRECTORY ) + { + return false; + } + } + return true; +} + +bool CATBase::IsFileReadOnly( const char* pFilename ) +{ + LOG_FUNC_ENTRY("CATBase::IsFileReadOnly"); + DWORD dwRet = GetFileAttributes( pFilename ); + if( dwRet == INVALID_FILE_ATTRIBUTES ) + return false; + if( dwRet & FILE_ATTRIBUTE_READONLY ) + return true; + return false; +} + +bool CATBase::SetFileReadOnly( const char* pFileName ) +{ + LOG_FUNC_ENTRY("CATBase::SetFileReadOnly"); + DWORD dw = GetFileAttributes( pFileName ); + if( dw == INVALID_FILE_ATTRIBUTES ) + return false; + if( dw & FILE_ATTRIBUTE_READONLY ) + return true; + dw = dw | FILE_ATTRIBUTE_READONLY ; + if ( SetFileAttributes( pFileName, dw ) ) + return true; + return false; +} +bool CATBase::SetFileWritable( const char* pFileName ) +{ + LOG_FUNC_ENTRY("CATBase::SetFileWritable"); + DWORD dw = GetFileAttributes( pFileName ); + if( dw == INVALID_FILE_ATTRIBUTES ) + return false; + if( ! dw & FILE_ATTRIBUTE_READONLY ) + return true; + dw = dw ^ FILE_ATTRIBUTE_READONLY ; + if ( SetFileAttributes( pFileName, dw ) ) + return true; + return false; +} + +// ----------------------------------------------------------------------------- +// CATBase::FileCopyToPath +// Copies file to given path +// ----------------------------------------------------------------------------- +bool CATBase::FileCopyToPath(const string& sFile, const string& sToPath) +{ + LOG_FUNC_ENTRY("CATBase::FileCopyToPath"); + // Display message + cout << AT_MSG << "Copy " << sFile << AT_FILE_TO << sToPath << endl; + if ( sFile.empty() || sToPath.empty() ) + { + LOG_FUNC_EXIT("CATBase::FileCopyToPath Error, empty parameter"); + return false; + } + // Copy using windows api (seems not to work when relavite path .. + /* + // Full path where to copy + string sDestination = sToPath; + // Append '\' to string if not exists + if ( sDestination.length() > 1 ) + { + const char cLastChar = sDestination[ sDestination.length() -1 ]; + if ( cLastChar != DASH ) + sDestination.append("\\"); + } + int iRet = 0; + iRet = CopyFile( sFile.c_str(), sDestination.c_str(), false ); + if ( iRet != 0 ) + { + return false; + } + */ + string sCommand; + sCommand.append( "copy /Y \""); + sCommand.append( sFile ); + sCommand.append( "\" \"" ); + sCommand.append( sToPath ); + sCommand.append( "\" > nul 2>&1" ); + LOG_STRING( sCommand ); + int iRet = 0; + iRet = (int)system( sCommand.c_str() ); + if ( iRet != 0 ) + return false; + return true; +} + +// ----------------------------------------------------------------------------- +// CATBase::FileMoveToPath +// Copies file to given path +// ----------------------------------------------------------------------------- +bool CATBase::FileMoveToPath(const string& sFile, const string& sToPath) +{ + LOG_FUNC_ENTRY("CATBase::FileMoveToPath"); + // Display message + cout << AT_MSG << "Move " << sFile << AT_FILE_TO << sToPath << endl; + if ( sFile.empty() || sToPath.empty() ) + { + LOG_FUNC_EXIT("CATBase::FileMoveToPath Error, empty parameter"); + return false; + } + // Move (again windows api function does not support relative path .. in it + /* + // Get filename from sFile + string sFileName = GetPathOrFileName( true, sFile ); + // Full path where to copy + string sDestination = sToPath; + // Append '\' to string if not exists + if ( sDestination.length() > 1 ) + { + const char cLastChar = sDestination[ sDestination.length() -1 ]; + if ( cLastChar != DASH ) + sDestination.append("\\"); + } + int iRet = 0; + iRet = MoveFile( sFile.c_str(), sDestination.c_str()); + if ( iRet != 0 ) + { + return false; + } + */ + string sCommand; + sCommand.append( "move /Y \""); + sCommand.append( sFile ); + sCommand.append( "\" \"" ); + sCommand.append( sToPath ); + sCommand.append( "\" > nul 2>&1" ); + LOG_STRING( sCommand ); + int iRet = 0; + iRet = (int)system( sCommand.c_str() ); + if ( iRet != 0 ) + return false; + return true; +} +// ----------------------------------------------------------------------------- +// CATBase::CreateTempPath +// Creates temporary directory path for given mmp file +// ----------------------------------------------------------------------------- +string CATBase::CreateTempPath(const string& sMmpFileWithPath) +{ + LOG_FUNC_ENTRY("CATBase::CreateTempPath"); + string sTempPath = GetPathOrFileName( false, sMmpFileWithPath ); + sTempPath.append( AT_TEMP_DIR ); + sTempPath.append( "\\" ); + return sTempPath; +} + +// ----------------------------------------------------------------------------- +// CATBase::RemovePathAndExt +// Removes extension from file name and returns file name without extension. +// ----------------------------------------------------------------------------- +string CATBase::RemovePathAndExt( string sFileName, bool bReverseFindExt) +{ + LOG_LOW_FUNC_ENTRY("CATBase::RemovePathAndExt"); + string sRet; + sFileName = GetPathOrFileName( true, sFileName ); + if ( bReverseFindExt ) + { + // Remove extension from reverse + size_t iPos = sFileName.find_last_of('.'); + if( iPos != string::npos ) + { + sFileName.resize( sFileName.find_last_of('.') ); + sRet = sFileName; + } + } + else + { + // Remove extension finding first . + size_t iPos = sFileName.find_first_of('.'); + if( iPos != string::npos ) + { + sFileName.resize( sFileName.find_first_of('.') ); + sRet = sFileName; + } + } + return sRet; +} + +// ----------------------------------------------------------------------------- +// CATBase::IsTargetTypeSupported +// Checks from constant array is this target unsupported +// ----------------------------------------------------------------------------- +bool CATBase::IsTargetTypeSupported(string sTargetType) +{ + LOG_FUNC_ENTRY("CATBase::IsTargetTypeSupported"); + // compare to list + int iArraySize = sizeof( UNSUPPORTED_TARGET_TYPES ) / sizeof( string ); + for ( int i=0 ; i < iArraySize ; i++ ) + { + string sUnsupported = UNSUPPORTED_TARGET_TYPES[i]; + // lowercase both + ChangeToLower(sTargetType); + ChangeToLower(sUnsupported); + // compare + if ( sUnsupported.compare( sTargetType ) == 0 ) + { + return false; + } + } + return true; +} + +// ----------------------------------------------------------------------------- +// CATBase::IsTargetTypeKernelSide +// Checks from constant array is this target type kernel side +// ----------------------------------------------------------------------------- +bool CATBase::IsTargetTypeKernelSide(string sTargetType) +{ + LOG_FUNC_ENTRY("CATBase::IsTargetTypeKernelSide"); + // compare to list + int iArraySize = sizeof( KERNEL_SIDE_TARGET_TYPES ) / sizeof( string ); + for ( int i=0 ; i < iArraySize ; i++ ) + { + string sUnsupported = KERNEL_SIDE_TARGET_TYPES[i]; + // lowercase both + ChangeToLower(sTargetType); + ChangeToLower(sUnsupported); + // compare + if ( sUnsupported.compare( sTargetType ) == 0 ) + { + return true; + } + } + return false; +} + +bool CATBase::CheckVariant( const string& sEpocRoot, const string& sVariant ) +{ + LOG_FUNC_ENTRY("CATBase::CheckVariant"); + string sFileToCheck; + // Add epoc root + if( sEpocRoot.size() > 1 ) + sFileToCheck.append( sEpocRoot ); + // Add path + sFileToCheck.append( VARIANT_DIR ) ; + // Add variant + sFileToCheck.append( sVariant ); + // Add extension + sFileToCheck.append( VARIANT_FILE_EXTENSION ); + // check does FileExists + return FileExists( sFileToCheck.c_str() ); +} +bool CATBase::IsDefaultVariant( const string& sEpocRoot ) +{ + LOG_FUNC_ENTRY("CATBase::IsDefaultVariant"); + string sFileToCheck; + // Add epoc root + if( sEpocRoot.size() > 1 ) + sFileToCheck.append( sEpocRoot ); + // Add path + sFileToCheck.append( VARIANT_DIR ) ; + // Add variant + sFileToCheck.append( "DEFAULT" ); + // Add extension + sFileToCheck.append( VARIANT_FILE_EXTENSION ); + // check does FileExists + return FileExists( sFileToCheck.c_str() ); +} + +// ----------------------------------------------------------------------------- +// CATBase::FileDelete +// FileDelete +// ----------------------------------------------------------------------------- +bool CATBase::FileDelete(const string& sFile, bool bPrint ) +{ + LOG_FUNC_ENTRY("CATBase::FileDelete"); + // does file even exists + if ( !FileExists( sFile.c_str() ) ) + return false; + // delete file + int iRet = _unlink( sFile.c_str() ); + // if print on display error + if ( iRet && bPrint ) + { + cout << AT_MSG << "Error, deleting file " << sFile + << endl; + } + // if print on display message + else if ( !iRet && bPrint ) + { + cout << AT_MSG << "Delete " << sFile << endl; + } + // return + if ( iRet ) + return false; + return true; +} +// ----------------------------------------------------------------------------- +// CATBase::DirDelete +// Delelete directory +// ----------------------------------------------------------------------------- +bool CATBase::DirDelete(const string& sDir, bool bPrint ) +{ + LOG_FUNC_ENTRY("CATBase::DirDelete"); + if ( sDir.find( AT_TEMP_DIR) == string::npos ) + return false; + + if ( sDir.length() < 2 ) + return false; + + string sDir2; + if ( sDir.at(1) != ':' ) + { + char cDir[MAX_LINE_LENGTH]; + GetCurrentDirectory( MAX_LINE_LENGTH , cDir ); + sDir2.append( cDir ); + sDir2.append( "\\" ); + sDir2.append( sDir ); + } + else + sDir2.append( sDir ); + + // does directory exists + DWORD dwRet = GetFileAttributes( sDir2.c_str() ); + if ( dwRet == INVALID_FILE_ATTRIBUTES ) + return false; + else if ( ! (dwRet & FILE_ATTRIBUTE_DIRECTORY) ) + { + return false; + } + // Delete dir + string sCmd( "rmdir /S /Q " ); + sCmd.append( sDir2 ); + sCmd.append( " > nul 2>&1" ); + int iRet = (int)system( sCmd.c_str() ); + if ( iRet && bPrint) + { + cout << AT_MSG << "Error, deleting directory " << sDir2 << endl; + } + else if ( !iRet && bPrint ) + { + cout << AT_MSG << "Delete directory " << sDir2 << endl; + } + if ( iRet ) + return false; + return true; +} + +// ----------------------------------------------------------------------------- +// CATBase::DirCreate +// Create directory +// ----------------------------------------------------------------------------- +bool CATBase::DirCreate(const string& sDir, bool bPrint ) +{ + LOG_FUNC_ENTRY("CATBase::DirCreate"); + + if ( sDir.length() < 2 ) + return false; + + string sDir2; + if ( sDir.at(1) != ':' ) + { + char cDir[MAX_LINE_LENGTH]; + GetCurrentDirectory( MAX_LINE_LENGTH , cDir ); + sDir2.append( cDir ); + sDir2.append( "\\" ); + sDir2.append( sDir ); + } + else + sDir2.append( sDir ); + + // does directory exists + DWORD dwRet = GetFileAttributes( sDir2.c_str() ); + if ( dwRet != INVALID_FILE_ATTRIBUTES ) + { + if( dwRet & FILE_ATTRIBUTE_DIRECTORY ) + return false; + } + // Create dir + string sCmd( "mkdir " ); + sCmd.append( sDir2 ); + sCmd.append( " > nul 2>&1" ); + int iRet = (int)system( sCmd.c_str() ); + if ( iRet && bPrint) + { + cout << AT_MSG << "Error, creating directory " << sDir2 << endl; + } + else if ( !iRet && bPrint ) + { + cout << AT_MSG << "Directory " << sDir2 << " created" << endl; + } + if ( iRet ) + return false; + return true; +} + +// ----------------------------------------------------------------------------- +// CATBase::ConvertTCHARtoString +// Convert TCHAR* to std::string +// ----------------------------------------------------------------------------- +string CATBase::ConvertTCHARtoString(TCHAR* charArray) +{ + LOG_LOW_FUNC_ENTRY("CATBase::ConvertTCHARtoString"); + // Loop char array + stringstream ss; + int iIndex = 0; + char c = (char) charArray[iIndex]; + // until null termination + while ( c != '\0' ) + { + ss << c; + iIndex++; + c = (char) charArray[iIndex]; + } + // return string + return ss.str(); +} + +// ----------------------------------------------------------------------------- +// CATBase::ConvertTCHARtoString +// Get list of files in directory +// ----------------------------------------------------------------------------- +vector CATBase::DirList(const string& sDirectory + , bool bListDirs, bool bAddPathToFile) +{ + LOG_FUNC_ENTRY("CATBase::DirList"); + // Create string to modify it + string sDir = sDirectory; + // Add if missing '\' & '*' to the sDirectory + if ( sDir.at( sDir.size()-1 ) != '\\' ) + sDir.append( "\\" ); + // Path to add to file string if specified + string sPath = sDir; + // Add * to for windows api to find all files + sDir.append( "*" ); + // convert directory string to LPCSTR + LPCSTR dir( sDir.c_str() ); + // vector to store file list + vector vFileList; + // Using win32 api to find list of files in directory + // file data "container" + WIN32_FIND_DATA fileData; + // handle to directory + HANDLE hFinder = FindFirstFile( dir, &fileData ); + if ( hFinder == INVALID_HANDLE_VALUE ) + { + // no files found + return vFileList; + } + // loop files add to vector and return + while( FindNextFile(hFinder, &fileData ) ) + { + DWORD dw = fileData.dwFileAttributes; + // skip if its directory and bListDirs not specified + if ( dw & FILE_ATTRIBUTE_DIRECTORY && ! bListDirs) + continue; + // add files to vector + string sFile = ConvertTCHARtoString( fileData.cFileName ); + // Add given path to file string if specified + if ( bAddPathToFile ) + sFile.insert( 0, sPath ); + vFileList.push_back( sFile ); + } + // Close file find handler + FindClose( hFinder ); + return vFileList; +} + +// ----------------------------------------------------------------------------- +// CATBase::ParseRelativePathToString +// ParseRelative +// ----------------------------------------------------------------------------- +void CATBase::ParseRelativePathString(string& sPathString) +{ + LOG_LOW_FUNC_ENTRY("CATBase::ParseRelativePathString"); + string sParsed; + // find .. + size_t iDots = sPathString.find( ".." ); + while ( iDots != string::npos ) + { + RemoveRelativePath( sPathString, iDots ); + iDots = sPathString.find( ".." ); + } +} + +// ----------------------------------------------------------------------------- +// CATBase::RemoveRelativePath +// Remove relative path from string (using given index) +// ----------------------------------------------------------------------------- +void CATBase::RemoveRelativePath(string& sString, size_t iDots) +{ + LOG_LOW_FUNC_ENTRY("CATBase::RemoveRelativePath"); + // Chck if accidentally given wrong parameter + if ( iDots == string::npos + || iDots < 1 ) + return; + // Parsed string + string sParsed; + // Find position of last backslash before dots + size_t i = sString.rfind("\\", iDots-2 ); + // Pickup start part (depending is the backslash at last parts first char) + if ( sString.at(iDots+2) != '\\' ) + sParsed = sString.substr( 0, i+1 ) ; + else + sParsed = sString.substr( 0, i ); + // Pick up last part + sParsed.append( sString.substr( iDots+2, sString.size() ) ); + sString = sParsed; +} + +// ----------------------------------------------------------------------------- +// Get extension from given string +// ----------------------------------------------------------------------------- +string CATBase::GetExtension(const string& sString) +{ + LOG_LOW_FUNC_ENTRY("CATBase::GetExtension"); + // find last . + size_t iDot = sString.find_last_of( "." ); + // return string after . if found + if ( iDot != string::npos ) + return sString.substr(iDot+1, sString.length()-(iDot+1) ); + // otherwise return given string + return sString; +} + +// ----------------------------------------------------------------------------- +// CATBase::DirectoryExists +// Check if given directory exists. +// ----------------------------------------------------------------------------- +bool CATBase::DirectoryExists( const char* pDirname ) +{ + LOG_FUNC_ENTRY("CATBase::DirectoryExists"); + size_t iLenght = strlen( pDirname ); + + if ( iLenght < 2 ) + return false; + + string sDir; + if ( pDirname[1] != ':' ) + { + char cDir[MAX_LINE_LENGTH]; + GetCurrentDirectory( MAX_LINE_LENGTH , cDir ); + sDir.append( cDir ); + sDir.append( "\\" ); + sDir.append( pDirname ); + } + else + sDir.append( pDirname ); + + DWORD dwRet = GetFileAttributes( sDir.c_str() ); + if( dwRet == INVALID_FILE_ATTRIBUTES ) + { + return false; + } + else + { + //Is file directory? + if( dwRet & FILE_ATTRIBUTE_DIRECTORY ) + { + return true; + } + else + { + return false; + } + } +} + +// ----------------------------------------------------------------------------- +// CATBase::ConvertUnixPathToWin +// ----------------------------------------------------------------------------- +void CATBase::ConvertUnixPathToWin( string& sPath ) +{ + LOG_LOW_FUNC_ENTRY("CATBase::ConvertUnixPathToWin"); + size_t iSpot = 0; + // convert '/' to '\' + iSpot = sPath.find( "/" ); + while( iSpot != string::npos ) + { + sPath.replace(iSpot,1, "\\"); + iSpot = sPath.find( "/", iSpot+1 ); + } + // convert '\\' to '\' + iSpot = sPath.find( "\\\\" ); + while( iSpot != string::npos ) + { + sPath.replace(iSpot,2,"\\"); + iSpot = sPath.find( "\\\\" ); + } +} + +// ----------------------------------------------------------------------------- +// CATBase::RemoveAllAfterDotIfTwoDots +// Removes all after first '.' +// if given string contains 2 '.' or more +// ----------------------------------------------------------------------------- +void CATBase::RemoveAllAfterDotIfTwoDots(string& sModName) +{ + LOG_LOW_FUNC_ENTRY("CATBase::RemoveAllAfterDotIfTwoDots"); + // did we find variable? + size_t found; + // Find first '.' + found = sModName.find("."); + if ( found != string::npos ) + { + // Try find second '.' + found = sModName.find(".", found+1); + if ( found != string::npos ) + { + // Remove all after first '.' + sModName = sModName.substr(0, sModName.find(".")+1 ); + } + } +} +// ----------------------------------------------------------------------------- +// CATBase::CreateTemporaryCpp +// ----------------------------------------------------------------------------- +bool CATBase::CreateTemporaryCpp( const string& sId, + const string& sPath + ,const string& sS60FileName + ,int iLogOption + ,int iIsDebug + ,int iAllocCallStackSize + ,int iFreeCallStackSize ) +{ + LOG_FUNC_ENTRY("CATBase::CreateTemporaryCpp"); + // Add slash to path if missing + string sTempCpp = sPath; + if( sTempCpp.at( sTempCpp.length() - 1 ) != '\\' ) + sTempCpp.append("\\"); + + // append temporary cpp name with id in middle + sTempCpp.append( AT_TEMP_CPP_LOWER_START ); + sTempCpp.append( sId ); + sTempCpp.append( AT_TEMP_CPP_LOWER_END ); + + //Open and truncate temporary cpp + ofstream out( sTempCpp.c_str() , ios::trunc ); + if ( ! out.good() ) + { + out.close(); + return false; + } + // Headers + out << "#include "; + // Is debug + out << "\nconst TInt ATTempDebug(" << iIsDebug << ");"; + // Log option + out << "\nconst TInt ATTempLogOption(" << iLogOption << ");"; + // Alloc call stack + out << "\nconst TInt ATTempAllocCallStackSize(" << iAllocCallStackSize << ");"; + // Free call stack + out << "\nconst TInt ATTempFreeCallStackSize(" << iFreeCallStackSize << ");"; + // Log file name + out << "\n_LIT( ATTempLogFileName, \"" << sS60FileName << "\" );"; + // Version number + out << "\n_LIT( ATTempVersion, \"" << ATOOL_COMPATIBILITY_STRING << "\" );"; + // Variable functions use enumeration values that are defined in memoryhook (customuser.h) + // We use constants here so that we don't need to include the header file, wich + // might cause problems. +/* Enumeration copied to comment for notes + enum TATOptions + { + ELogFileName = 1, + EVersion = 2 , + ELogOption = 3, + EDebug = 4, + EAllocCallStackSize = 5, + EFreeCallStackSize = 6 + }; +*/ + out << "\nTInt GetInt( const TUint8 aType )"; + out << "\n{"; + out << "\nswitch( aType )"; + out << "\n{"; + out << "\ncase 4: return ATTempDebug; "; + out << "\ncase 3: return ATTempLogOption;"; + out << "\ncase 5: return ATTempAllocCallStackSize;"; + out << "\ncase 6: return ATTempFreeCallStackSize;"; + out << "\ndefault: return KErrArgument;"; + out << "\n}"; + out << "\n}"; + out << "\nTPtrC GetString( const TUint8 aType )"; + out << "\n{"; + out << "\nswitch( aType )"; + out << "\n{"; + out << "\ncase 1: return ATTempLogFileName();"; + out << "\ncase 2: return ATTempVersion();"; + out << "\ndefault: return KNullDesC();"; + out << "\n}"; + out << "\n}"; + + /** Todo: Old way of separate functions, these here for backup support and to ease testing. */ + /** Unnessesary in the future, so can be removed then (1.8.2). */ + + out << "\n_LIT( KFileName, \""; + out << sS60FileName; + out << "\" );\n"; + + // Hardcoded version number for support. + out << "\n/* The AnalyzeTool version number used. */"; + out << "\n_LIT( KAtoolVersion, \"1.7.5;1.9.1\" );\n"; + + out << "\nconst TFileName LogFileName()"; + out << "\n {"; + out << "\n return TFileName( KFileName() );"; + out << "\n }"; + + out << "\nTUint32 AllocCallStackSize()"; + out << "\n {"; + out << "\n return TUint32( "; + out << iAllocCallStackSize; + out << " );\n"; + out << "\n }"; + + out << "\nTUint32 FreeCallStackSize()"; + out << "\n {"; + out << "\n return TUint32( "; + out << iFreeCallStackSize; + out << " );\n"; + out << "\n }"; + + out << "\nconst TFileName AtoolVersion()"; + out << "\n {"; + out << "\n return TFileName( KAtoolVersion() );"; + out << "\n }"; + + out << "\nTUint32 LogOption()"; + out << "\n {"; + out << "\n return TUint32( "; + out << iLogOption; + out << " );"; + out << "\n }"; + + out << "\nTUint32 IsDebug()"; + out << "\n {"; + out << "\n return TUint32( "; + out << iIsDebug; + out << " );"; + out << "\n }"; + + // End of file and close + out << "\n\n// End of File\n"; + out.close(); + cout << AT_MSG << "Created " << sTempCpp << endl; + return true; +} + +// ----------------------------------------------------------------------------- +// CATBase::IsDataFile +// ----------------------------------------------------------------------------- +bool CATBase::IsDataFile( string sFile ) +{ + LOG_FUNC_ENTRY("CATBase::IsDataFile"); + // Check that sFile not empty + if ( sFile.empty() || sFile.length() < 1 ) + return false; + + // Temporary line char array. + char cLineFromFile[MAX_LINE_LENGTH]; + //Open file + ifstream in( sFile.c_str() ); + + //File open ok? + if( !in.good() ) + return false; + + //Read all lines + in.getline( cLineFromFile, MAX_LINE_LENGTH ); + + string sLineFromFile( cLineFromFile ); + in.close(); + if( sLineFromFile.find( "DATA_FILE_VERSION" ) != string::npos ) + return true; + else + return false; +} + + +// ----------------------------------------------------------------------------- +// CATBase::ParseStringToVector +// ----------------------------------------------------------------------------- +vector CATBase::ParseStringToVector( const string& sInput, char separator ) +{ + LOG_LOW_FUNC_ENTRY("CATBase::ParseStringToVector"); + string sString(sInput); + // Elements vector + vector vStrings; + size_t iPos = sString.find( separator ); + // If can not find it return vector with just one element + if ( iPos == string::npos ) + { + // Don't add empty item into vector. + if ( sString.size() > 0 ) + vStrings.push_back( sString ); + return vStrings; + } + // Loop elements + while( iPos != string::npos ) + { + string sElement = sString.substr(0, iPos); + vStrings.push_back( sElement ); + sString.erase(0, iPos +1 ); + iPos = sString.find( separator ); + } + // Add last element if any + if ( sString.size() > 0 ) + vStrings.push_back( sString ); + // Return elements + return vStrings; +} + +// ----------------------------------------------------------------------------- +// CATBase::FilterString +// Filter string out of unwanted characters. The list of allowed +// characters is defined in CFILTERSTRING. +// ----------------------------------------------------------------------------- +string CATBase::FilterString( const string& sString ) +{ + LOG_LOW_FUNC_ENTRY("CATBase::FilterString"); + string sFiltered; + for( size_t i = 0 ; i < sString.length() ; i++ ) + { + const char p = sString.at( i ); + if ( strchr( CFILTERSTRING, p ) != 0 ) + sFiltered.push_back( p ); + } + return sFiltered; +} + +// ----------------------------------------------------------------------------- +// CATBase::FilterExtraSpaces +// Replaces multiple continuous spaces with single. Won't leave +// spaces in start or end of string. +// ----------------------------------------------------------------------------- +void CATBase::FilterExtraSpaces( string& sString ) +{ + LOG_LOW_FUNC_ENTRY("CATBase::FilterExtraSpaces"); + string sFiltered; + // Loop thru char array. + for( size_t i = 0 ; i < sString.length(); i++ ) + { + // Is char space? + if ( sString.at( i ) == ' ' ) + { + // Pick up space if filtered does not contain char as last. + if ( sFiltered.rbegin() == sFiltered.rend() ) + sFiltered.push_back( sString.at( i ) ); + else if ( * ( sFiltered.rbegin() ) != ' ' ) + sFiltered.push_back( sString.at( i ) ); + } + else + sFiltered.push_back( sString.at( i ) ); + } + + // Remove first and/or last character if it is space. + if ( sFiltered.begin() != sFiltered.end() ) + { + if( * ( sFiltered.begin() ) == ' ' ) + sFiltered.erase( 0, 1 ); + } + if ( sFiltered.rbegin() != sFiltered.rend() ) + { + if( * ( sFiltered.rbegin() ) == ' ' ) + sFiltered.resize( sFiltered.length()-1 ); + } + sString = sFiltered; +} + + +bool CATBase::hexToDec( string& sHex, unsigned int& iDec ) +{ + LOG_LOW_FUNC_ENTRY("CATBase::hexToDec"); + istringstream ss( sHex ); + ss.setf( ios::hex, ios::basefield ); + if( ( ss >> iDec ) ) + return true; + return false; +} + +bool CATBase::hexToDec( string& sHex, int& iDec ) +{ + LOG_LOW_FUNC_ENTRY("CATBase::hexToDec"); + istringstream ss( sHex ); + ss.setf( ios::hex, ios::basefield ); + if( ( ss >> iDec ) ) + return true; + return false; +} + +bool CATBase::hexToDec( string& sHex, unsigned long& ulDec ) +{ + LOG_LOW_FUNC_ENTRY("CATBase::hexToDec"); + istringstream ss( sHex ); + ss.setf( ios::hex, ios::basefield ); + if( ( ss >> ulDec ) ) + return true; + return false; +} + +bool CATBase::hexToDec( string& sHex, unsigned long long& ullDec ) +{ + LOG_LOW_FUNC_ENTRY("CATBase::hexToDec"); + istringstream ss( sHex ); + ss.setf( ios::hex, ios::basefield ); + if( ( ss >> ullDec ) ) + return true; + return false; +} + +/** +* Used to create array of integer & hex value pairs. +*/ +struct CHexMap +{ + char chr; + int value; +}; + +// ----------------------------------------------------------------------------- +// CATBase::_httoi +// ----------------------------------------------------------------------------- +unsigned long CATBase::_httoi(const char *value) +{ + LOG_LOW_FUNC_ENTRY("CATBase::_httoi"); + unsigned long l; + string s( value ); + if ( CATBase::hexToDec( s, l ) ) + return l; + return 0; +} + + +// ----------------------------------------------------------------------------- +// CATBase::NumberToHexString(int) +// ----------------------------------------------------------------------------- +string CATBase::NumberToHexString( unsigned int i ) +{ + LOG_LOW_FUNC_ENTRY("CATBase::IntToHexString"); + stringstream ss; + ss << "0x" << hex << i; + string retval; retval = ss.str().c_str(); + return retval; +} +// ----------------------------------------------------------------------------- +// CATBase::NumberToHexString(long) +// ----------------------------------------------------------------------------- +string CATBase::NumberToHexString( unsigned long i ) +{ + LOG_LOW_FUNC_ENTRY("CATBase::IntToHexString"); + stringstream ss; + ss << "0x" << hex << i; + string retval; retval = ss.str().c_str(); + return retval; +} + +// ----------------------------------------------------------------------------- +// CATBase::IsHexCharacter +// ----------------------------------------------------------------------------- +bool CATBase::IsHexCharacter(const TCHAR *value) +{ + LOG_LOW_FUNC_ENTRY("CATBase::IsHexCharacter"); + const int HexMapL = 22; + CHexMap HexMap[HexMapL] = + { + {'0', 0}, {'1', 1}, + {'2', 2}, {'3', 3}, + {'4', 4}, {'5', 5}, + {'6', 6}, {'7', 7}, + {'8', 8}, {'9', 9}, + {'A', 10}, {'B', 11}, + {'C', 12}, {'D', 13}, + {'E', 14}, {'F', 15}, + {'a', 10}, {'b', 11}, + {'c', 12}, {'d', 13}, + {'e', 14}, {'f', 15} + }; + bool found = false; + for (int i = 0; i < HexMapL; i++) + { + if(HexMap[i].chr == *value) + { + found = true; + break; + } + } + return found; +} + +// ----------------------------------------------------------------------------- +// CATBase::IsAscii(const char*,const unsigned int) +// ----------------------------------------------------------------------------- +bool CATBase::IsAscii( const char* pInput, const unsigned int iLength ) +{ + LOG_LOW_FUNC_ENTRY("CATBase::IsAscii"); + bool bRet = true; + const char* pPoint = pInput; + for( unsigned int i = 0 ; i < iLength ; i++) + { + if( !__isascii(*pPoint) ) + { + bRet = false; + break; + } + pPoint++; + } + return bRet; +} + +// ----------------------------------------------------------------------------- +// CATBase::GetEpocRoot( string& sEpocRoot ) +// ----------------------------------------------------------------------------- +bool CATBase::GetEpocRoot( string& sEpocRoot ) +{ + LOG_FUNC_ENTRY( "CATBase::GetEpocRoot" ); + bool bRet = true; + //Find EPOCROOT from environment variable + char* pEpocRoot = getenv ("EPOCROOT"); + if( pEpocRoot == NULL ) + { + const char pDevicesPath[] = "C:\\Program Files\\Common Files\\Symbian\\devices.xml"; + CATParseXML parser; + //Find EPOCROOT from devices + sEpocRoot = parser.GetEpocRootPathFromXML(pDevicesPath); + if( sEpocRoot.empty() ) + { + printf("EPOCROOT not set to environment variables.\n"); + bRet = false; + } + } + else + { + sEpocRoot.append( pEpocRoot ); + LOG_STRING( "EpocRoot :" << sEpocRoot ); + } + //Remove trailing slash + if ( sEpocRoot.size() > 1 && sEpocRoot[ sEpocRoot.length()-1 ] == '\\' ) + sEpocRoot.resize( sEpocRoot.length()-1 ); + return bRet; +} +//End of file diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/src/CATDatParser.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/src/CATDatParser.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,1542 @@ +/* +* 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: Class responsible to parse data files +* +*/ + + +#include "../inc/CATDatParser.h" +#include "../inc/CATProject.h" +#include "../inc/CATModule2.h" +#include "../inc/CATMemoryAddress.h" +#include "../inc/catromsymbol.h" + +// ----------------------------------------------------------------------------- +// CATDatParser::CATDatParser +// Constructor only for testing! +// (No module vector defined so no locating codelines / call stacks) +// ----------------------------------------------------------------------------- +CATDatParser::CATDatParser() +{ + LOG_FUNC_ENTRY("CATDatParser::CATDatParser"); + Construct(); +} + +// ----------------------------------------------------------------------------- +// CATDatParser::CATDatParser +// Constructor +// ----------------------------------------------------------------------------- +CATDatParser::CATDatParser(vector* pModules ) +{ + LOG_FUNC_ENTRY("CATDatParser::CATDatParser"); + Construct(); + m_pModules = pModules; +} + +// ----------------------------------------------------------------------------- +// CATDatParser::Construct +// "Real" constructor +// ----------------------------------------------------------------------------- +void CATDatParser::Construct() +{ + LOG_FUNC_ENTRY("CATDatParser::Construct"); + + m_iDataVersion = 1; // Default version of data. + m_bDllLoadFound = false; + m_bProcessStartFound = false; + m_bSubtestOnGoing = false; + + m_DataSaver.InitXML(); + + m_eBuildType = -2; + m_eProcess_state = not_started; + m_eProjectBuildType = -1; + + m_iCurrentProcessId = 0; + m_iLeakNumber = 0; + m_iLogLevel = 3; + m_iOffSet = 0; + + m_iPinPointedLeaks = 0; + m_iPinPointedSubTestLeaks = 0; + m_iSubtestStartHandleCount = 0; + m_iSuccesfullRuns = 0; + m_iTotalNumberOfLeaks = 0; + m_iTotalRuns = 0; + + m_pRomSymbol = 0; + m_pModules = 0; + + m_sCurrentProcessName = ""; + m_sInputFile = ""; + m_sInputFileTemp = ""; + m_sOutputFile = ""; + m_sProjectPlatform = ""; + m_vRomSymbolFiles.clear(); + m_vDllLoadModList.clear(); + m_vDllLoadModListSubTest.clear(); + m_vHandleLeaks.clear(); + m_vMemoryAddress.clear(); +} + +// ----------------------------------------------------------------------------- +// CATDatParser::~CATDatParser +// Destructor +// ----------------------------------------------------------------------------- +CATDatParser::~CATDatParser() +{ + LOG_FUNC_ENTRY("CATDatParser::~CATDatParser"); + + if ( m_In.is_open() ) + m_In.close(); + // Delete temporary input file if any + if ( !m_sInputFileTemp.empty() ) + { + if ( FileExists( m_sInputFileTemp.c_str() ) ) + FileDelete( m_sInputFileTemp, false ); + } + // Clean memory addresses if any + CleanMemoryAddresses(); + // Delete rom symbol. + if ( m_pRomSymbol ) + { + delete m_pRomSymbol; + m_pRomSymbol = NULL; + } +} + +// ----------------------------------------------------------------------------- +// CATDatParser::Analyze +// Analyze given data file +// ----------------------------------------------------------------------------- +int CATDatParser::Analyze() +{ + LOG_FUNC_ENTRY("CATDatParser::Analyze"); + // Return if input file not set + if ( m_sInputFile.empty() ) + return AT_RETURN_CODE::INVALID_DATA_FILE; + // If open close first + if ( m_In.is_open() ) + m_In.close(); + // Open file + m_In.open( m_sInputFile.c_str() ); + if ( ! m_In.good() ) + return AT_RETURN_CODE::INVALID_DATA_FILE; + try { + // If rom symbol file specified. + if ( ! m_vRomSymbolFiles.empty() ) + { + // Create new rom symbol file "parser". + m_pRomSymbol = new CATRomSymbol(); + m_pRomSymbol->m_bShowProgressMessages = true; + // Set symbol files. + if ( ! m_pRomSymbol->SetSymbols( m_vRomSymbolFiles ) ) + { + cout << AT_MSG << "Rom/Rofs symbols error: " << m_pRomSymbol->GetError() << endl; + // If file open fails we delete it and will not use it. + delete m_pRomSymbol; + m_pRomSymbol = NULL; + cout << AT_MSG << "Analyze aborted." << endl; + return AT_RETURN_CODE::SYMBOL_FILE_ERROR; + } + } + // Return code + int iRet = 0; + // Clear variables + ClearParsingVariables(); + // If output defined disable printing + if ( ! m_sOutputFile.empty() ) + m_DataSaver.SetPrintFlag( false ); + // Header + Header(); + // Parsing + iRet = Parse(); + // Footer + if ( iRet == AT_RETURN_CODE::OK ) + Footer(); + // If output defined save xml + if ( ! m_sOutputFile.empty() ) + m_DataSaver.SaveLinesToFile( m_sOutputFile.c_str(), XML_DATA ); + // Return + return iRet; + } catch ( int i ) + { + cout << AT_MSG << "Error, Analyze failed. : " << i << endl; + return AT_RETURN_CODE::UNHANDLED_EXCEPTION; + } +} +// ----------------------------------------------------------------------------- +// CATDatParser::Header +// Print header of report +// ----------------------------------------------------------------------------- +void CATDatParser::Header() +{ + LOG_FUNC_ENTRY("CATDatParser::Header"); + // Analyze report header + m_DataSaver.AddString( "Atool.exe v." ); + m_DataSaver.AddString( ATOOL_VERSION ); + m_DataSaver.AddString( "\n" ); + m_DataSaver.AddString( "Analyzing memory leaks..." ); + m_DataSaver.AddLineToLast(); +} + +// ----------------------------------------------------------------------------- +// CATDatParser::Footer +// Print footer of report +// ----------------------------------------------------------------------------- +void CATDatParser::Footer() +{ + LOG_FUNC_ENTRY("CATDatParser::Footer"); + m_DataSaver.AddString( "\nTotal Runs: " ); + m_DataSaver.AddInteger( m_iTotalRuns ); + m_DataSaver.AddLineToLast(); + + int iFailedRuns = m_iTotalRuns - m_iSuccesfullRuns; + m_DataSaver.AddString( "Failed Runs: " ); + m_DataSaver.AddInteger( iFailedRuns ); + m_DataSaver.AddLineToLast(); + + char cTemp[128]; + string sResult( itoa( m_iTotalRuns, cTemp, 10 ) ); + sResult.append( ";" ); + sResult.append( itoa( iFailedRuns, cTemp, 10 ) ); + sResult.append( ";" ); + + m_DataSaver.SaveXML( sResult, RESULT ); +} + +// ----------------------------------------------------------------------------- +// CATDatParser::ClearParsingVariables +// Clear/Reset all member variables related to parsing data file +// ----------------------------------------------------------------------------- +void CATDatParser::ClearParsingVariables() +{ + LOG_FUNC_ENTRY("CATDatParser::ClearParsingVariables"); + // Clear variables related to analyze + m_eProcess_state = not_started; + m_bProcessStartFound = false; + m_bDllLoadFound = false; + m_iTotalNumberOfLeaks = 0; + m_iPinPointedLeaks = 0; + m_iLeakNumber = 0; + m_iTotalRuns = 0; + m_iSuccesfullRuns = 0; + m_bSubtestOnGoing = false; + m_iSubtestStartHandleCount = 0; + CleanMemoryAddresses(); +} + +// ----------------------------------------------------------------------------- +// CATDatParser::Parse +// Parses data file. Note! header and footer of the report are done in +// separate functions. +// ----------------------------------------------------------------------------- +int CATDatParser::Parse() +{ + LOG_FUNC_ENTRY("CATDatParser::Parse"); + // Read all lines + char cLine[MAX_LINE_LENGTH]; + do + { + string sLine; + try { + m_In.getline( cLine, MAX_LINE_LENGTH ); + sLine = cLine ; + } catch(...) + { + LOG_STRING( AT_MSG << "Unexpected error, reading data file." ); + continue; + } + if( sLine.find( LABEL_DATA_FILE_VERSION ) != string::npos ) + { + // Check data file version + if( sLine.find( AT_DATA_FILE_VERSION ) == string::npos ) + { + return AT_RETURN_CODE::WRONG_DATA_FILE_VERSION; + } + } + else if( sLine.find( LABEL_PROCESS_START ) != string::npos ) + { + if ( ! ParseProcessStart( sLine ) ) + return AT_RETURN_CODE::ANALYZE_ERROR; + } + else if( sLine.find( LABEL_DLL_LOAD ) != string::npos ) + { + if ( ! ParseDllLoad( sLine ) ) + return AT_RETURN_CODE::ANALYZE_ERROR; + } + else if( sLine.find( LABEL_DLL_UNLOAD ) != string::npos ) + { + if ( ! ParseDllUnload( sLine ) ) + return AT_RETURN_CODE::ANALYZE_ERROR; + } + else if( sLine.find( LABEL_MEM_LEAK ) != string::npos) + { + if ( ! ParseMemLeak( sLine ) ) + return AT_RETURN_CODE::ANALYZE_ERROR; + } + else if( sLine.find( LABEL_PROCESS_END ) != string::npos ) + { + if ( ! ParseProcessEnd( sLine ) ) + return AT_RETURN_CODE::ANALYZE_ERROR; + } + else if( sLine.find( LABEL_ERROR_OCCURED ) != string::npos ) + { + if ( ! ParseErrorOccured( sLine ) ) + return AT_RETURN_CODE::ANALYZE_ERROR; + } + else if( sLine.find( LABEL_HANDLE_LEAK ) != string::npos ) + { + if ( ! ParseHandleLeak( sLine ) ) + return AT_RETURN_CODE::ANALYZE_ERROR; + } + else if( sLine.find( LABEL_TEST_START ) != string::npos ) + { + if ( ! ParseTestStart( sLine ) ) + return AT_RETURN_CODE::ANALYZE_ERROR; + } + else if( sLine.find( LABEL_TEST_END ) != string::npos ) + { + if ( ! ParseTestEnd( sLine ) ) + return AT_RETURN_CODE::ANALYZE_ERROR; + } + else if( sLine.find( LABEL_LOGGING_CANCELLED ) != string::npos ) + { + if ( ! ParseLoggingCancelled( sLine ) ) + return AT_RETURN_CODE::ANALYZE_ERROR; + } + } + while( m_In.good() ); + // Message of failed run if process start was last line in data. + if ( m_eProcess_state == ongoing ) + { + m_DataSaver.AddString( "Test run failed.\n" ); + m_DataSaver.AddLineToLast(); + } + return AT_RETURN_CODE::OK; +} + +// ----------------------------------------------------------------------------- +// CATDatParser::ParseProcessStart +// ----------------------------------------------------------------------------- +bool CATDatParser::ParseProcessStart( string& sLine) +{ + LOG_FUNC_ENTRY("CATDatParser::ParseProcessStart"); + if ( m_eProcess_state == ongoing ) + { + m_DataSaver.AddString( "Test run failed.\n" ); + m_DataSaver.AddLineToLast(); + } + m_eProcess_state = ongoing; + m_bProcessStartFound = true; + + // Clear handle leaks + m_vHandleLeaks.clear(); + // Increment runs + m_iTotalRuns++; + // Clean leak count + m_iTotalNumberOfLeaks = 0; + // Clean pin pointed leaks count. + m_iPinPointedLeaks = 0; + // Clean leak number + m_iLeakNumber = 0; + + // Clean loaded mods + m_vDllLoadModList.clear(); + m_vDllLoadModListSubTest.clear(); + + // Skip text PROCESS_START + GetStringUntilNextSpace( sLine ); + // Get process name + m_sCurrentProcessName = GetStringUntilNextSpace( sLine ); + // Get Pid + string sPid = GetStringUntilNextSpace( sLine ); + m_iCurrentProcessId = _httoi( sPid.c_str() ); + + // Header for process tart + m_DataSaver.AddString( "\n--------------------------------\n" ); + m_DataSaver.AddString( "Test Run start (" ); + m_DataSaver.AddString( m_sCurrentProcessName.c_str() ); + m_DataSaver.AddString( "): " ); + + // Get start time + string sTime = GetStringUntilNextSpace( sLine ); + sTime = ConvertTimeToLocalTime( sTime ); + m_DataSaver.AddString( sTime.c_str() ); + + // Create data for xml + string sData( sTime ); + sData.append( ";" ); + + // Build mode UDEB/UREL. + string sBuildType = GetStringUntilNextSpace( sLine ); + + m_DataSaver.AddString( " Build target: " ); + if( sBuildType.compare( "0" ) == 0 ) + { + m_eBuildType = CATProject::UREL; + } + else if( sBuildType.compare( "1" ) == 0 ) + { + m_eBuildType = CATProject::UDEB; + } + m_DataSaver.AddString( CATProject::GetBuildTypeString( m_eBuildType ).c_str() ); + + // Version. + string sVersion = GetStringUntilNextSpace( sLine ); + unsigned int iVer = 0; + if ( hexToDec( sVersion, iVer ) && iVer != 0 ) + m_iDataVersion = iVer; + + // End line in data. + m_DataSaver.AddLineToLast(); + + // xml + sData.append( CATProject::GetBuildTypeString( m_eBuildType ) ); + sData.append( ";" ); + sData.append( m_sCurrentProcessName ); + m_DataSaver.SaveXML( sData, RUN ); + + // If projects platform defined check that it is same in data. (future feature). + if ( ! m_sProjectPlatform.empty() ) + { + // If platform info is added to data file do check here. + } + // If projects build type defined check that it is same in data. + if ( m_eProjectBuildType != -1 ) + { + if ( m_eBuildType != m_eProjectBuildType ) + { + string sError(AT_MSG); + sError.append( "Error, analyzed data has build type of " ); + sError.append( CATProject::GetBuildTypeString( m_eBuildType ) ); + sError.append( " and project has build type " ); + sError.append( CATProject::GetBuildTypeString( m_eProjectBuildType ) ); + sError.append( ". Pinpointed code lines are not valid." ); + m_DataSaver.AddString( sError.c_str(), false ); + m_DataSaver.AddLineToLast(); + } + } + return true; +} + +// ----------------------------------------------------------------------------- +// CATDatParser::ParseProcessEnd +// ----------------------------------------------------------------------------- +bool CATDatParser::ParseProcessEnd( string& sLine ) +{ + LOG_FUNC_ENTRY("CATDatParser::ParseProcessEnd"); + GetStringUntilNextSpace( sLine ); + + // Get process id + string sProcessID = GetStringUntilNextSpace( sLine ); + unsigned long iProcessID = _httoi( sProcessID.c_str() ); + + // Get time + string sTime = GetStringUntilNextSpace( sLine ); + + // Convert leak time + sTime = ConvertTimeToLocalTime( sTime ); + + // Process started? + if( iProcessID == m_iCurrentProcessId ) + { + m_iSuccesfullRuns++; + m_DataSaver.AddLineToLast(); + m_DataSaver.AddString( "Test Run end (" ); + m_DataSaver.AddString( m_sCurrentProcessName.c_str() ); + m_DataSaver.AddString( "): " ); + m_DataSaver.AddString( sTime.c_str() ); + m_DataSaver.AddLineToLast(); + m_DataSaver.AddString( "Build target: " ); + m_DataSaver.AddString( CATProject::GetBuildTypeString( m_eBuildType ).c_str() ); + m_DataSaver.AddLineToLast(); + + m_eProcess_state = stopped; + // Number of leaks + if ( m_iLogLevel == 1 || m_iLogLevel == 2 ) + { + if ( m_iPinPointedLeaks > 0 ) + { + m_DataSaver.AddInteger( m_iPinPointedLeaks ); + m_DataSaver.AddString( " number of pinpointed memory leak(s)." ); + m_DataSaver.AddLineToLast(); + } + m_DataSaver.AddInteger( m_iLeakNumber ); + m_DataSaver.AddString( " total number of memory leak(s)." ); + m_DataSaver.AddLineToLast(); + } + else + { + m_DataSaver.AddInteger( m_iTotalNumberOfLeaks ); + m_DataSaver.AddString( " memory leak(s) found." ); + m_DataSaver.AddLineToLast(); + } + + // xml + char cTemp[128]; + m_DataSaver.SaveXML( itoa( m_iTotalNumberOfLeaks, cTemp, 10 ) , MEM_LEAKS ); + + // Print all modules which have leaks + for( size_t i = 0 ; i < m_vDllLoadModList.size() ; i++ ) + { + if( m_vDllLoadModList.at(i).iLeaks > 0 ) + { + m_DataSaver.AddInteger( m_vDllLoadModList.at(i).iLeaks ); + m_DataSaver.AddString( " memory leak(s) in module: " ); + m_DataSaver.AddString( m_vDllLoadModList.at(i).sModuleName.c_str() ); + m_DataSaver.AddLineToLast(); + + // xml + string sModuleNameAndLeaks( m_vDllLoadModList[i].sModuleName ); + sModuleNameAndLeaks.append(";"); + sModuleNameAndLeaks.append( itoa( m_vDllLoadModList[i].iLeaks, cTemp, 10 ) ); + m_DataSaver.SaveXML( sModuleNameAndLeaks , MEM_LEAK_MODULE ); + } + } + + if ( m_vHandleLeaks.size() > 0 ) + { + // We have handle leaks + bool bHandLeaksFound = false; + int iTotalNrOfLeaks = 0; + // Print handle leaks + for( size_t i = 0 ; i < m_vHandleLeaks.size() ; i++ ) + { + string sTempHandleLeak( m_vHandleLeaks[i] ); + // Name. + string sHandleLeakModule( GetStringUntilNextSpace( sTempHandleLeak ) ); + // Count. + string sNrOfLeaks( GetStringUntilNextSpace(sTempHandleLeak) ); + unsigned long iNrOfLeaks = _httoi( sNrOfLeaks.c_str() ); + iTotalNrOfLeaks += iNrOfLeaks; + if( iNrOfLeaks ) + { + if( !bHandLeaksFound ) + { + m_DataSaver.SaveXML( sNrOfLeaks , HANDLE_LEAKS ); + } + bHandLeaksFound = true; + m_DataSaver.AddInteger( iNrOfLeaks ); + // Just print out how many leaks found. + // Because its always unknown. + m_DataSaver.AddString( " handle leak(s) found." ); + m_DataSaver.AddLineToLast(); + + // xml + string sXMLInfo( sHandleLeakModule ); + sXMLInfo.append( ";" ); sXMLInfo.append( sNrOfLeaks ); + m_DataSaver.SaveXML( sXMLInfo , HANDLE_LEAK_MODULE ); + } + } + // Update number if handle leaks + m_DataSaver.SaveXML( itoa( iTotalNrOfLeaks, cTemp, 10 ) , HANDLE_LEAKS ); + if( !bHandLeaksFound ) + { + //m_DataSaver.AddLineToLast(); + m_DataSaver.AddString( TEXT_NO_HANDLE_LEAKS ); + m_DataSaver.AddLineToLast(); + } + } + else + { + // No handle leaks + m_DataSaver.AddLineToLast(); + m_DataSaver.AddString( TEXT_NO_HANDLE_LEAKS ); + m_DataSaver.AddLineToLast(); + } + + // Process end to xml + m_DataSaver.SaveXML( sTime, RUN_END ); + // Reset current process + m_iCurrentProcessId = 0; + } + + // If no dll load or process start found + if ( ! m_bProcessStartFound || !m_bDllLoadFound ) + { + m_DataSaver.AddLineToLast(); + m_DataSaver.AddString( AT_ANALYZE_INSUFFICIENT_LOGGING_DATA ); + m_DataSaver.AddLineToLast(); + } + + return true; +} + +// ----------------------------------------------------------------------------- +// CATDatParser::ParseDllLoad +// ----------------------------------------------------------------------------- +bool CATDatParser::ParseDllLoad( string& sLine ) +{ + LOG_FUNC_ENTRY("CATDatParser::ParseDllLoad"); + //DLL_LOAD + m_bDllLoadFound = true; + DLL_LOAD_INFO structDllInfo; + structDllInfo.iStartAddress = 0; + structDllInfo.iEndAddress = 0; + structDllInfo.iLeaks = 0; + + // Skip "DLL_LOAD " + GetStringUntilNextSpace( sLine ); + + // Get module name + structDllInfo.sModuleName = GetStringUntilNextSpace( sLine ); + ChangeToLower( structDllInfo.sModuleName ); + + // Create module from this if project platform emulator + if ( _stricmp( "winscw", m_sProjectPlatform.c_str() ) == 0 ) + CreateWinscwModule( structDllInfo.sModuleName ); + + if ( m_iDataVersion >= AT_DLL_TIMESTAMP_DATA_VERSION ) + { + // Pickup module loading time. + string sLoadTime = GetStringUntilNextSpace( sLine ); + unsigned long long ull; + if ( hexToDec( sLoadTime, ull ) ) + structDllInfo.iLoadTime = ull; + } + + // Get dll start memory string address from line + // Convert string address to real memory address + structDllInfo.iStartAddress = + _httoi( GetStringUntilNextSpace( sLine ).c_str() ); + + // Get dll end memory string address from line + // Convert string address to real memory address + structDllInfo.iEndAddress = + _httoi( + GetStringUntilNextSpace( sLine ).c_str() ); + + // Is module already loaded, if not add it to list. + bool bFound = false; + for( vector::iterator it = m_vDllLoadModList.begin(); + it != m_vDllLoadModList.end() ; it++ ) + { + if( (*it).sModuleName.compare( structDllInfo.sModuleName ) == 0 ) + { + bFound = true; + break; + } + } + if( ! bFound ) + m_vDllLoadModList.push_back( structDllInfo ); + + // Sub test module list. + bFound = false; + for( vector::iterator it = m_vDllLoadModListSubTest.begin(); + it != m_vDllLoadModListSubTest.end() ; it++ ) + { + if( (*it).sModuleName.compare( structDllInfo.sModuleName ) == 0 ) + { + bFound = true; + break; + } + } + if( ! bFound ) + m_vDllLoadModListSubTest.push_back( structDllInfo ); + + return true; +} + +// ----------------------------------------------------------------------------- +// CATDatParser::ParseDllUnload +// ----------------------------------------------------------------------------- +bool CATDatParser::ParseDllUnload( string& sLine ) +{ + LOG_FUNC_ENTRY("CATDatParser::ParseDllUnload"); + + // Ignore unloads on older version because no timestamps. + if ( m_iDataVersion < AT_DLL_TIMESTAMP_DATA_VERSION ) + { + return true; + } + + // Skip "DLL_UNLOAD " + GetStringUntilNextSpace( sLine ); + + // Get module name + string sModuleName = GetStringUntilNextSpace( sLine ); + ChangeToLower( sModuleName ); + + // Unload time + unsigned long long ull; + string sUnload = GetStringUntilNextSpace( sLine ); + if ( ! hexToDec( sUnload, ull ) ) + return true; + + // Set module unload time. + vector::iterator it; + for( it = m_vDllLoadModList.begin() ; it != m_vDllLoadModList.end() ; it++ ) + { + if ( sModuleName.compare( it->sModuleName ) == 0 ) + { + (*it).iUnloadTime = ull; + break; + } + } + for( it = m_vDllLoadModListSubTest.begin() ; it != m_vDllLoadModListSubTest.end() ; it++ ) + { + if ( sModuleName.compare( it->sModuleName ) == 0 ) + { + (*it).iUnloadTime = ull; + break; + } + } + return true; +} +// ----------------------------------------------------------------------------- +// CATDatParser::ParseLoggingCancelled +// ----------------------------------------------------------------------------- +bool CATDatParser::ParseLoggingCancelled( string& sLine ) +{ + LOG_FUNC_ENTRY("CATDatParser::ParseLoggingCancelled"); + // Skip text "LOGGING_CANCELLED" + GetStringUntilNextSpace( sLine ); + + // Get time + string sTime( GetStringUntilNextSpace( sLine ) ); + sTime = ConvertTimeToLocalTime( sTime ); + m_DataSaver.AddString( "Logging Cancelled." ); + m_DataSaver.AddLineToLast(); + return true; +} + +// ----------------------------------------------------------------------------- +// CATDatParser::ParseHandleLeak +// ----------------------------------------------------------------------------- +bool CATDatParser::ParseHandleLeak( string& sLine ) +{ + LOG_FUNC_ENTRY("CATDatParser::ParseHandleLeak"); + // Skip text "HANDLE_LEAK" + GetStringUntilNextSpace( sLine ); + m_vHandleLeaks.push_back( sLine ); + return true; +} + +// ----------------------------------------------------------------------------- +// CATDatParser::ParseTestStart +// ----------------------------------------------------------------------------- +bool CATDatParser::ParseTestStart( string& sLine ) +{ + LOG_FUNC_ENTRY("CATDatParser::ParseTestStart"); + m_bSubtestOnGoing = true; + m_iLeakNumber = 0; + m_iPinPointedSubTestLeaks = 0; + + // Reset subtest leaked modules list + for( size_t i = 0 ; i < m_vDllLoadModListSubTest.size() ; i++ ) + { + m_vDllLoadModListSubTest.at(i).iLeaks = 0; + } + + // Skip text "TEST_START" + GetStringUntilNextSpace( sLine ); + // Time + string sTime( GetStringUntilNextSpace( sLine ) ); + sTime = ConvertTimeToLocalTime( sTime ); + // Name + string sSubTestName( GetStringUntilNextSpace( sLine ) ); + m_DataSaver.AddLineToLast(); + + // Get handle count in subtest start + string sSubTestStartHandleCount( GetStringUntilNextSpace( sLine ) ); + m_iSubtestStartHandleCount = atoi( sSubTestStartHandleCount.c_str() ); + + // Add start to report + m_DataSaver.AddString( "\nSub test (" ); + m_DataSaver.AddString( sSubTestName.c_str() ); + m_DataSaver.AddString( ") start: " ); + m_DataSaver.AddString( sTime.c_str() ); + + // m_DataSaver.AddLineToLast(); + + // Add start to xml + string sResult( sSubTestName ); + sResult.append( ";" ); + sResult.append( sTime ); + sResult.append( ";" ); + m_DataSaver.SaveXML( sResult, TEST_START ); + return true; +} + +// ----------------------------------------------------------------------------- +// CATDatParser::ParseTestEnd +// ----------------------------------------------------------------------------- +bool CATDatParser::ParseTestEnd( string& sLine ) +{ + LOG_FUNC_ENTRY("CATDatParser::ParseTestEnd"); + // Skip text "TEST_END" + GetStringUntilNextSpace( sLine ); + + // Time + string sTime( GetStringUntilNextSpace( sLine ) ); + sTime = ConvertTimeToLocalTime( sTime ); + + // Name + string sSubTestName( GetStringUntilNextSpace( sLine ) ); + m_DataSaver.AddLineToLast(); + + // Add test end info to report + m_DataSaver.AddString( "Sub test (" ); + m_DataSaver.AddString( sSubTestName.c_str() ); + m_DataSaver.AddString( ") end: " ); + m_DataSaver.AddString( sTime.c_str() ); + m_DataSaver.AddLineToLast(); + + // Leak count to report in subtest + if( m_iLeakNumber > 0 ) + { + if ( m_iLogLevel == 1 || m_iLogLevel == 2 ) + { + m_DataSaver.AddInteger( m_iPinPointedSubTestLeaks ); + m_DataSaver.AddString( " number of pinpointed memory leaks." ); + m_DataSaver.AddLineToLast(); + m_DataSaver.AddInteger( m_iLeakNumber ); + m_DataSaver.AddString( " memory leaks found." ); + } + else + { + m_DataSaver.AddInteger( m_iLeakNumber ); + m_DataSaver.AddString( " memory leaks found." ); + } + } + else + { + m_DataSaver.AddString( "No memory leaks found." ); + } + m_DataSaver.AddLineToLast(); + + // Use sTime to store info to xml + sTime.append(";"); + char cTemp[128]; + // Print all modules whitch have leaks + for( unsigned int i = 0 ; i < m_vDllLoadModListSubTest.size() ; i++ ) + { + if( m_vDllLoadModListSubTest.at(i).iLeaks > 0 ) + { + // Normal report + m_DataSaver.AddInteger( m_vDllLoadModListSubTest[i].iLeaks ); + m_DataSaver.AddString( " memory leaks in module: " ); + m_DataSaver.AddString( m_vDllLoadModListSubTest.at(i).sModuleName.c_str() ); + m_DataSaver.AddLineToLast(); + // xml + string sModuleNameAndLeaks( m_vDllLoadModListSubTest.at(i).sModuleName ); + sModuleNameAndLeaks.append(";"); + sModuleNameAndLeaks.append( itoa( m_vDllLoadModListSubTest.at(i).iLeaks, cTemp, 10 ) ); + m_DataSaver.SaveXML( sModuleNameAndLeaks , SUBTEST_MEM_LEAK_MODULE ); + } + } + // Handle count + int iEndHandleCount = atoi( GetStringUntilNextSpace( sLine ).c_str() ); + // Is there handle leaks in subtest? + if( iEndHandleCount > m_iSubtestStartHandleCount ) + { + // Print normal report + m_DataSaver.AddInteger( iEndHandleCount - m_iSubtestStartHandleCount ); + m_DataSaver.AddString( " handle leaks in subtest: " ); + m_DataSaver.AddString( sSubTestName.c_str() ); + m_DataSaver.AddString( "." ); + m_DataSaver.AddLineToLast(); + + // Print handle leaks to XML + string sNrOfHandleLeaks( itoa( iEndHandleCount - m_iSubtestStartHandleCount, cTemp, 10 ) ); + sNrOfHandleLeaks.append( ";" ); + m_DataSaver.SaveXML( sNrOfHandleLeaks, SUBTEST_HANDLE_LEAKS ); + } + else + { + // No handle leaks + m_DataSaver.AddString( TEXT_NO_HANDLE_LEAKS ); + m_DataSaver.AddLineToLast(); + } + // Save xml + m_DataSaver.SaveXML( sTime, TEST_END ); + // Back to normal leaks + m_bSubtestOnGoing = false; + return true; +} + +// ----------------------------------------------------------------------------- +// CATDatParser::ParseErrorOccured +// ----------------------------------------------------------------------------- +bool CATDatParser::ParseErrorOccured( string& sLine ) +{ + LOG_FUNC_ENTRY("CATDatParser::ParseErrorOccured"); + string sTime,sError; + + // Skip text "ERROR_OCCURED:" + GetStringUntilNextSpace( sLine ); + + // Get error + sError = GetStringUntilNextSpace( sLine ); + // Get and convert error time + sTime = GetStringUntilNextSpace( sLine ); + sTime = ConvertTimeToLocalTime( sTime ); + + // Print error line + m_DataSaver.AddLineToLast(); + m_DataSaver.AddString( "Error occured on: " ); + m_DataSaver.AddString( sTime.c_str() ); + m_DataSaver.AddString( ". " ); + m_DataSaver.AddString( "Symbian error code: " ); + m_DataSaver.AddString( sError.c_str() ); + m_DataSaver.AddString( "." ); + m_DataSaver.AddLineToLast(); + + return true; +} + +// ----------------------------------------------------------------------------- +// CATDatParser::ParseMemLeak +// ----------------------------------------------------------------------------- +bool CATDatParser::ParseMemLeak( string& sLine ) +{ + LOG_FUNC_ENTRY("CATDatParser::ParseMemLeak"); + // Increment leak count + if ( ! m_bSubtestOnGoing ) + m_iTotalNumberOfLeaks++; + + // Increase leak number + m_iLeakNumber++; + + // Leak data variables + string sModuleName; + string sLeakSize; + string sTime; + unsigned long long iTime = 0; + string sLeakAddress; + + // Skip text "MEM_LEAK" + GetStringUntilNextSpace( sLine ); + // Get leak address + sLeakAddress = GetStringUntilNextSpace( sLine ); + // Get time + sTime = GetStringUntilNextSpace( sLine ); + // Convert time to decimal + hexToDec( sTime, iTime ); + // Get memory reserve size + sLeakSize = GetStringUntilNextSpace( sLine ); + // Convert leak time + sTime = ConvertTimeToLocalTime( sTime ); + + // Loop thru call stack and put memory addresses in vector + CleanMemoryAddresses(); // Clean memory address vector + CATMemoryAddress* pMemAddr = 0; + vector vStrings = ParseStringToVector( sLine, ' ' ); + for( size_t i = 0; i < vStrings.size() ; i++ ) + { + pMemAddr = new CATMemoryAddress( vStrings.at(i), m_iOffSet ); + // Set address time + pMemAddr->SetTime( iTime ); + // Set address module name + if ( pMemAddr->FindSetModuleName( &m_vDllLoadModList ) ) + { + // Increment leaks in module once + if ( sModuleName.empty() ) + { + if ( m_bSubtestOnGoing ) + m_vDllLoadModListSubTest.at( pMemAddr->GetDllLoadInfoIndex() ).iLeaks++; + else + m_vDllLoadModList.at( pMemAddr->GetDllLoadInfoIndex() ).iLeaks++; + // Set leak's module where it was located. + sModuleName = pMemAddr->GetModuleName(); + } + } + // Add it to vector + m_vMemoryAddress.push_back( pMemAddr ); + } + // If logging level is 0 Skip printing / locating code lines for call stack items. + if ( m_iLogLevel == 0 ) + return true; + if ( m_pModules && vStrings.size() > 0 ) + { + // Have we successfully located code line for memory address + bool bSuccesfullAddressToLine = false; + for( size_t x = 0; x < m_vMemoryAddress.size(); x++ ) + { + int iIndexInDll = m_vMemoryAddress.at( x )->GetDllLoadInfoIndex(); + if ( iIndexInDll != -1 ) + { + // Dll module name from data file + string sDllName = m_vDllLoadModList.at( iIndexInDll ).sModuleName; + // Find module from project. These are read from makefiles. + for ( size_t y = 0; y < m_pModules->size() ; y++ ) + { + // Module name from project data (makefiles) + string sModuleName = m_pModules->at( y )->GetBinaryName(); + // If we find module from project ones, use it to located code line for memory address + // Note! dll names can be pretty messy i.e. DLL_LOAD 10281fc6.dll{000a0000}[10281fc6] 81d57b88 81e60a90 + if ( sDllName.find( sModuleName ) != string::npos ) + { + m_pModules->at( y )->AddressToLine( m_vMemoryAddress.at( x ) ); + if ( ! bSuccesfullAddressToLine ) + { + int iPPState = m_vMemoryAddress.at( x )->GetAddressToLineState(); + if ( iPPState == CATMemoryAddress::EXACT || iPPState == CATMemoryAddress::FUNCTION ) + { + bSuccesfullAddressToLine = true; + if ( m_bSubtestOnGoing ) + m_iPinPointedSubTestLeaks++; + else + m_iPinPointedLeaks++; + } + } + } + } + } + } + // If rom/rofs specified we use it to try get binary and function names + // for addresses currently out of process range. + if ( m_pRomSymbol ) + { + for( size_t x = 0; x < m_vMemoryAddress.size(); x++ ) + { + if ( m_vMemoryAddress.at(x)->GetAddressToLineState() == CATMemoryAddress::OUT_OF_PROCESS + || m_vMemoryAddress.at(x)->GetAddressToLineState() == CATMemoryAddress::OUT_OF_RANGE ) + { + m_pRomSymbol->AddressToLine( m_vMemoryAddress.at(x) ); + } + } + } + } + // Print leak + PrintMemLeak( sTime, sLeakSize, sLeakAddress, sModuleName); + return true; +} + +// ----------------------------------------------------------------------------- +// CATDatParser::PrintMemLeak +// ----------------------------------------------------------------------------- +void CATDatParser::PrintMemLeak(const string& sTime, + const string& sLeakSize, + const string& sLeakAddr, + const string& sModuleName) +{ + LOG_FUNC_ENTRY("CATDatParser::PrintMemLeak"); + // Print header data of leak + m_DataSaver.AddString("\nMemory leak "); + m_DataSaver.AddInteger( m_iLeakNumber, true); + + // Leak size + m_DataSaver.AddString( " (" ); + m_DataSaver.AddInteger( _httoi( sLeakSize.c_str() ), true ); + m_DataSaver.AddString( " bytes) " ); + + // Leak address + m_DataSaver.AddString("(0x"); + m_DataSaver.AddString( sLeakAddr.c_str(), true ); + m_DataSaver.AddString( ") " ); + + // Time + m_DataSaver.AddString( sTime.c_str(), true ); + m_DataSaver.AddString( " " ); + + // Module name + m_DataSaver.AddString( sModuleName.c_str(), true ); + m_DataSaver.SaveCarbideDataHeader(); + + // Add header line + m_DataSaver.AddLineToLast(); + + // Print the call stack items + for( size_t i = 0 ; i < m_vMemoryAddress.size() ; i++ ) + { + // On log levels 1 & 2 we only print located code lines. + #ifndef ADDR2LINE + if( + ( m_iLogLevel == 1 || m_iLogLevel == 2 ) + && + ( m_vMemoryAddress.at(i)->GetAddressToLineState() != CATMemoryAddress::EXACT + && m_vMemoryAddress.at(i)->GetAddressToLineState() != CATMemoryAddress::FUNCTION ) + ) + { + // Skips to next + continue; + } + #endif + #ifdef ADDR2LINE + if( ( m_iLogLevel == 1 || m_iLogLevel == 2 ) + && m_vMemoryAddress.at(i)->GetAddressToLineState() != CATMemoryAddress::EXACT ) + { + // Skips to next + continue; + } + #endif + else if ( m_vMemoryAddress.at(i)->GetAddressToLineState() == CATMemoryAddress::OUT_OF_PROCESS ) + { + // Is memory address out of modules range + string sTemp; + sTemp.append( m_vMemoryAddress.at(i)->GetAddressString() ); + sTemp.append( " Address out of process memory."); + m_DataSaver.AddString( sTemp.c_str(), true ); + m_DataSaver.AddLineToLast(); + continue; + } + + // Print memory address + m_DataSaver.AddString( m_vMemoryAddress.at(i)->GetAddressString().c_str(), true ); + + // Space (only for console output) + m_DataSaver.AddString( " " ); + + m_DataSaver.AddCarbideData( + NumberToHexString( m_vMemoryAddress.at(i)->GetOffSetFromModuleStart() ) ); + + // Module name + m_DataSaver.AddString( m_vMemoryAddress.at(i)->GetModuleName().c_str(), true ); + + // Print call stack memory address details depending on state of memory address + switch( m_vMemoryAddress.at(i)->GetAddressToLineState() ) + { + // Address outside of known processes + case CATMemoryAddress::OUT_OF_PROCESS: + m_DataSaver.AddLineToLast(); + break; + // Address located outside of known modules symbols + case CATMemoryAddress::OUT_OF_RANGE: + m_DataSaver.AddString( " " ); + m_DataSaver.AddString( "???", true ); + m_DataSaver.AddLineToLast(); + break; + // Symbol state is currently used when using rom symbol file. + // From it we get module name & function name. + case CATMemoryAddress::SYMBOL: + m_DataSaver.AddString( " " ); + m_DataSaver.AddString( m_vMemoryAddress.at(i)->GetFunctionName().c_str(), true ); + if ( ! m_vMemoryAddress.at( i )->GetFileName().empty() ) + { + m_DataSaver.AddString( " (" ); + m_DataSaver.AddString( m_vMemoryAddress.at(i)->GetFileName().c_str(), true ); + m_DataSaver.AddString( ")" ); + } + m_DataSaver.AddLineToLast(); + break; + // Lst & Map implementation + #ifndef ADDR2LINE + case CATMemoryAddress::FUNCTION: + case CATMemoryAddress::EXACT: + m_DataSaver.AddString( " " ); + m_DataSaver.AddString( m_vMemoryAddress.at(i)->GetFunctionName().c_str(), true ); + // Small difference displaying details depending on build urel/udeb + if ( m_eBuildType == CATProject::UREL ) + { + // UREL + // Set build info to data saver + m_DataSaver.SetBuild( false ); + // urel = functionname: linenumber (filename) + m_DataSaver.AddString( ": " ); + if ( m_vMemoryAddress.at(i)->GetFunctionLineNumber() != -1 ) + m_DataSaver.AddInteger( m_vMemoryAddress.at(i)->GetFunctionLineNumber(), true ); + else if ( m_vMemoryAddress.at(i)->GetExactLineNumber() != -1 ) + m_DataSaver.AddInteger( m_vMemoryAddress.at(i)->GetExactLineNumber(), true ); + m_DataSaver.AddString( " (" ); + m_DataSaver.AddString( m_vMemoryAddress.at(i)->GetFileName().c_str(), true ); + m_DataSaver.AddString( ")" ); + m_DataSaver.AddLineToLast(); + } + else + { + // UDEB + // udeb = functionname: (filename:linenumber) + m_DataSaver.AddString( " (" ); + m_DataSaver.AddString( m_vMemoryAddress.at(i)->GetFileName().c_str(), true ); + m_DataSaver.AddString( ":" ); + if( m_vMemoryAddress.at(i)->GetExactLineNumber() != -1 ) + m_DataSaver.AddInteger( m_vMemoryAddress.at(i)->GetExactLineNumber(), true ); + else + m_DataSaver.AddString( "???", true ); + m_DataSaver.AddString( ")" ); + m_DataSaver.AddLineToLast(); + } + break; + #endif + // addr2line implementation (new). + #ifdef ADDR2LINE + case CATMemoryAddress::FUNCTION: + m_DataSaver.AddString( " " ); + m_DataSaver.AddString( m_vMemoryAddress.at(i)->GetFunctionName().c_str(), true ); + m_DataSaver.AddString( " (" ); + m_DataSaver.AddString( m_vMemoryAddress.at(i)->GetFileName().c_str(), true ); + m_DataSaver.AddString( ":" ); + if( m_vMemoryAddress.at(i)->GetExactLineNumber() != -1 ) + m_DataSaver.AddInteger( m_vMemoryAddress.at(i)->GetFunctionLineNumber(), true ); + else + m_DataSaver.AddString( "???", true ); + m_DataSaver.AddString( ")" ); + m_DataSaver.AddLineToLast(); + break; + case CATMemoryAddress::EXACT: + m_DataSaver.AddString( " " ); + m_DataSaver.AddString( m_vMemoryAddress.at(i)->GetFunctionName().c_str(), true ); + m_DataSaver.AddString( " (" ); + m_DataSaver.AddString( m_vMemoryAddress.at(i)->GetFileName().c_str(), true ); + m_DataSaver.AddString( ":" ); + if( m_vMemoryAddress.at(i)->GetExactLineNumber() != -1 ) + m_DataSaver.AddInteger( m_vMemoryAddress.at(i)->GetExactLineNumber(), true ); + else + m_DataSaver.AddString( "???", true ); + m_DataSaver.AddString( ")" ); + m_DataSaver.AddLineToLast(); + break; + #endif + } // End switch + // On logging level 1 we only print one located code line + #ifndef ADDR2LINE + if ( m_iLogLevel == 1 && ( m_vMemoryAddress.at(i)->GetAddressToLineState() == CATMemoryAddress::EXACT || + m_vMemoryAddress.at(i)->GetAddressToLineState() == CATMemoryAddress::FUNCTION ) ) + break; + #endif + #ifdef ADDR2LINE + if ( m_iLogLevel == 1 && m_vMemoryAddress.at(i)->GetAddressToLineState() == CATMemoryAddress::EXACT ) + break; + #endif + } // End call stack items loop +} + +// ----------------------------------------------------------------------------- +// CATDatParser::SetInputFile +// ----------------------------------------------------------------------------- +void CATDatParser::SetInputFile(const string& sInputFile) +{ + LOG_FUNC_ENTRY("CATDatParser::SetInputFile"); + m_sInputFile = sInputFile; +} + +// ----------------------------------------------------------------------------- +// CATDatParser::SetOutputFile +// ----------------------------------------------------------------------------- +void CATDatParser::SetOutputFile(const string& sOutpuFile) +{ + LOG_FUNC_ENTRY("CATDatParser::SetOutputFile"); + m_sOutputFile = sOutpuFile; +} + +// ----------------------------------------------------------------------------- +// CATDatParser::SetRomSymbolFiles +// ----------------------------------------------------------------------------- +void CATDatParser::SetRomSymbolFiles(const vector& vRomSymbolFiles) +{ + LOG_FUNC_ENTRY("CATDatParser::SetRomSymbolFiles"); + m_vRomSymbolFiles = vRomSymbolFiles; +} + +// ----------------------------------------------------------------------------- +// CATDatParser::SetLogLevel +// ----------------------------------------------------------------------------- +void CATDatParser::SetLogLevel(int iLogLevel) +{ + LOG_FUNC_ENTRY("CATDatParser::SetLogLevel"); + m_iLogLevel = iLogLevel; +} + +// ----------------------------------------------------------------------------- +// CATDatParser::GetLogLevel +// ----------------------------------------------------------------------------- +int CATDatParser::GetLogLevel() const +{ + LOG_LOW_FUNC_ENTRY("CATDatParser::GetLogLevel"); + return m_iLogLevel; +} + +// ----------------------------------------------------------------------------- +// CATDatParser::CleanMemoryAddresses +// ----------------------------------------------------------------------------- +void CATDatParser::CleanMemoryAddresses() +{ + LOG_LOW_FUNC_ENTRY("CATDatParser::CleanMemoryAddresses"); + // Cleanup memory addressses. + for( vector::iterator it = m_vMemoryAddress.begin(); it != m_vMemoryAddress.end(); it++ ) + { + delete *it; + } + m_vMemoryAddress.clear(); +} + +// ----------------------------------------------------------------------------- +// CATDatParser::ConvertTimeToLocalTime +// ----------------------------------------------------------------------------- +string CATDatParser::ConvertTimeToLocalTime( string sInputTime ) +{ + LOG_LOW_FUNC_ENTRY("CATDatParser::ConvertTimeToLocalTime"); + //Is process end abnormal? + if( sInputTime.compare( LABEL_ABNORMAL ) == 0 ) + { + return string( AT_ANALYZE_ABNORMAL_EXIT ); + } + else + // Check that input time is at least 32-bit + if( sInputTime.length() <= 8 ) + { + sInputTime.clear(); + return sInputTime; + } + + string sTemp = sInputTime; + const char* pTemp = sTemp.c_str(); + + // Are all characters hex + for( unsigned int i = 0 ; i < sTemp.size() ; i++ ) + { + if( !IsHexCharacter( (pTemp + i) ) ) + { + return sInputTime; + } + } + + // Get LSB bits + string sLsb; + sLsb.append( sInputTime.substr( sInputTime.length()-8, sInputTime.length() ) ); + unsigned int iLsbTime = (unsigned int)_httoi( sLsb.c_str() ); + + // Get MSB bits + string sMsb; + sMsb.append( sInputTime.substr( 0, sInputTime.length()-8 ) ); + unsigned int iMsbTime = (unsigned int)_httoi( sMsb.c_str() ); + + // Get time in microsecods + long long sdf = iMsbTime * 0x100000000 + iLsbTime; + + // Get original time (starting at year 1970 ) + long long llOrigTime = sdf; + + // Get seconds + sdf = ( sdf )/1000000; + + // Check that sdf contains some time value + if( sdf <= 0) + { + // Error in time calculation + // Return empty string + sInputTime.clear(); + return sInputTime; + } + + // Original time after year 1970 in seconds + long long llOrignTimeInSeconds = sdf; + + // Calculate new time which does not include millisecods + long long llDiffTime = (llOrignTimeInSeconds * 1000000); + + // Calculate time difference in milliseconds + int llDiffTimeInMilliSecods = (int)( llOrigTime - llDiffTime )/1000; + + // Convert difference time to char + char cDiffInMilliSeconds[20]; + _itoa( llDiffTimeInMilliSecods, cDiffInMilliSeconds, 10 ); + + // Time info structure + struct tm *timeinfo; + + // Get local time + timeinfo = localtime ( (time_t*) &sdf ); + + // Create string and append memory leak time to it + string sTime; + sTime.append( asctime( timeinfo ) ); + + // Remove last char of locale time string which is \n + sTime.resize( (int)sTime.length()-1 ); + + // Get last space index + int iLastSpace = (int)sTime.find_last_of(" "); + + // If last space index is valid + if( iLastSpace <= (int)sTime.length() && iLastSpace > 0) + { + string sTempTime; + // Append first part of original time string + sTempTime.append( sTime.substr( 0, iLastSpace ) ); + + // Append millisecods + sTempTime.append( "." ); + sTempTime.append( cDiffInMilliSeconds ); + + // Append the rest of the original time string part + sTempTime.append( sTime.substr( iLastSpace, sTime.length())); + + // Clear original and append new time string which includes millisecods + sTime.clear(); + sTime.append( sTempTime ); + } + + // Return memory leak time + return sTime.c_str(); +} + +bool CATDatParser::CreateWinscwModule( const string& sBinaryName ) +{ + LOG_FUNC_ENTRY( "CATDatParser::CreateWinscwModule" ); + // Is module already created? + for( vector::iterator it = m_pModules->begin(); it != m_pModules->end(); it++ ) + { + if ( _stricmp( sBinaryName.c_str(), (*it)->GetBinaryName().c_str() ) == 0 ) + return true; + } + // No create new one and set its values. + CATModule2* mod = new CATModule2(); + mod->SetTarget( RemovePathAndExt( sBinaryName, true ) ); + mod->SetRequestedTargetExt( GetExtension( sBinaryName ) ); + mod->SetReleasePath( string( "\\epoc32\\release" ) ); + if ( m_eBuildType == CATProject::UDEB ) + mod->SetFullVariantPath( string( "winscw\\udeb" ) ); + else + mod->SetFullVariantPath( string( "winscw\\urel" ) ); + mod->SetVariantPlatform( string( "winscw" ) ); + m_pModules->push_back( mod ); + return true; +} + +// ----------------------------------------------------------------------------- +// CATDatParser::FindModuleUsingAddress +// Function finds module using given address. +// ----------------------------------------------------------------------------- +int CATDatParser::FindModuleUsingAddress( unsigned long iAddress ) const +{ + LOG_LOW_FUNC_ENTRY("CATDatParser::FindModuleUsingAddress"); + int iRet = -1; + for( unsigned int i = 0 ; i < m_vDllLoadModList.size() ; i++ ) + { + // Is address between start and end address? + if( iAddress > m_vDllLoadModList[i].iStartAddress && iAddress < m_vDllLoadModList[i].iEndAddress ) + { + iRet = i; + break; + } + } + return iRet; +} + +// ----------------------------------------------------------------------------- +// CATDatParser::FindModuleUsingPID +// Function finds module using module id. +// ----------------------------------------------------------------------------- +/* +int CATDatParser::FindModuleUsingPID( unsigned long iPID ) const +{ + LOG_FUNC_ENTRY("CATDatParser::FindModuleUsingPID"); + + int iRet = -1; + + // Change module name characters to lowercase + for( unsigned int i = 0 ; i < m_vDllLoadModList.size() ; i++ ) + { + if( m_vDllLoadModList[i].iPID == iPID ) + { + iRet = i; + break; + } + } + return iRet; +} +*/ +// ----------------------------------------------------------------------------- +// CATDatParser::FindModuleUsingName +// Function finds module using module name. +// ----------------------------------------------------------------------------- +int CATDatParser::FindModuleUsingName( const char* pModName ) +{ + LOG_LOW_FUNC_ENTRY("CATDatParser::FindModuleUsingName"); + + // Mod name empty? + if( pModName == NULL || *pModName == 0 ) + return -1; + + int iRet = -1; + string sModName( pModName ); + // Change module name characters to lowercase + ChangeToLower( sModName ); + // Remove variant marks (dots) + RemoveAllAfterDotIfTwoDots( sModName); + for( unsigned int i = 0 ; i < m_vDllLoadModList.size() ; i++ ) + { + string sTemp( m_vDllLoadModList[i].sModuleName ); + ChangeToLower( sTemp ); + // Remove variant marks (dots) + RemoveAllAfterDotIfTwoDots( sTemp ); + if( sTemp.find( sModName ) != string::npos ) + { + iRet = i; + break; + } + } + return iRet; +} + +// ----------------------------------------------------------------------------- +// CATDatParser::SetPrintFlag +// ----------------------------------------------------------------------------- +void CATDatParser::SetPringFlag( bool bPrintFlag ) +{ + LOG_FUNC_ENTRY("CATDatParser::SetPringFlag"); + m_DataSaver.SetPrintFlag( bPrintFlag ); +} +// ----------------------------------------------------------------------------- +// CATDatParser::SetOffSet +// ----------------------------------------------------------------------------- +void CATDatParser::SetOffSet( int iOffSet ) +{ + LOG_FUNC_ENTRY("CATDatParser::SetOffSet"); + m_iOffSet = iOffSet; +} + +// ----------------------------------------------------------------------------- +// CATDatParser::GetOffSet +// ----------------------------------------------------------------------------- +int CATDatParser::GetOffSet( ) const +{ + LOG_LOW_FUNC_ENTRY("CATDatParser::GetOffSet"); + return m_iOffSet; +} + +// ----------------------------------------------------------------------------- +// Set project platform. +// ----------------------------------------------------------------------------- +void CATDatParser::SetProjectPlatform( const string& sPlatform ) +{ + LOG_FUNC_ENTRY("CATDatParser::SetProjectPlatform"); + m_sProjectPlatform = sPlatform; + + // Check that platform not empty before determing platform from it. + if ( sPlatform.empty() ) + return; + + // Set functions offset in mapfiles correct (depending on platform). + if ( _stricmp( sPlatform.c_str(), "armv5" ) == 0 ) + { + m_iOffSet = FUNCTIONS_OFFSET_IN_MAP_FILE_ARMV5; + } + else if ( _stricmp( sPlatform.c_str(), "winscw" ) == 0 ) + { + m_iOffSet = FUNCTIONS_OFFSET_IN_MAP_FILE_WINSCW; + } + else if ( _stricmp( sPlatform.c_str(), "gcce" ) == 0 ) + { + m_iOffSet = FUNCTIONS_OFFSET_IN_GCCE; + } + else + { + LOG_STRING( AT_MSG << "Error, cannot set function's offset in map file, invalid platform: " << sPlatform ); + } +} + +// ----------------------------------------------------------------------------- +// Set projects build type. Use enumeration defined in CATProject. +// ----------------------------------------------------------------------------- +void CATDatParser::SetProjectBuildType( int eBuildType ) +{ + LOG_FUNC_ENTRY("CATDatParser::SetProjectBuildType"); + m_eProjectBuildType = eBuildType; +} + +//EOF diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/src/CATDataSaver.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/src/CATDataSaver.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,873 @@ +/* +* 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 CATDataSaver. +* +*/ + + +#include "../inc/catdatasaver.h" + +#include + +#if defined(XERCES_NEW_IOSTREAMS) +#include +#else +#include +#endif + +// Line feed char sequence used in XML report +wchar_t AT_XML_LINEFEEDS[3] = L"\r\n"; + +// ----------------------------------------------------------------------------- +// CATDataSaver::CATDataSaver +// Constructor. +// ----------------------------------------------------------------------------- +CATDataSaver::CATDataSaver( void ) +{ + LOG_FUNC_ENTRY("CATDataSaver::CATDataSaver"); + m_iLoggingLevel = DEFAULT_LOGGING_LEVEL; + m_bPrintImmediately = true; + m_bXMLInitOk = false; + m_bUdebBuild = true; + + m_iRunNumber = 1; + + m_pDomDoc = NULL; + m_pRootElem = NULL; + m_Serializer = NULL; + m_pCurrentLeakElem = NULL; + m_pRunElement = NULL; + m_pMemoryLeaks = NULL; + m_pHandleLeaks = NULL; + m_pCurrentSubTestElem = NULL; + m_pSubtestMemoryLeaks = NULL; +} + +// ----------------------------------------------------------------------------- +// CATDataSaver::~CATDataSaver +// Destructor. +// ----------------------------------------------------------------------------- +CATDataSaver::~CATDataSaver(void) +{ + LOG_FUNC_ENTRY("CATDataSaver::~CATDataSaver"); + if( m_bXMLInitOk ) + { + if( m_Serializer ) + delete m_Serializer; + + m_pDomDoc->release(); + xercesc::XMLPlatformUtils::Terminate(); + } +} + +// ----------------------------------------------------------------------------- +// CATDataSaver::SaveLinesToFile +// Gets logging level. +// ----------------------------------------------------------------------------- +void CATDataSaver::SaveLinesToFile( const char* pFileName, int iDataToSave ) +{ + LOG_FUNC_ENTRY("CATDataSaver::SaveLinesToFile"); + + // Nothing to print? + if( m_vLines.empty() ) + { + printf( "No output data." ); + return; + } + if( iDataToSave != XML_DATA ) + { + ofstream out( pFileName ); + + if( !out.good() ) + { + printf( "Can not open file: %s\n", pFileName ); + return; + } + switch( iDataToSave ) + { + case TEXT_DATA: + for( int i = 0 ; i < (int)m_vLines.size() ; i++ ) + { + out << m_vLines[i].c_str(); + } + break; + } + out.close(); + } + else + { + if( m_bXMLInitOk ) + { + xercesc::XMLFormatTarget* myFormTarget = NULL; + try + { + // Create format + myFormTarget = new xercesc::LocalFileFormatTarget( pFileName ); + + // Set line-feeds to dom writer + m_Serializer->setNewLine( AT_XML_LINEFEEDS ); + + // Set human-readable property. Note! Api already changed in >2.7 + // so this will cause error/problems if linked to newer library. + m_Serializer->setFeature( xercesc::XMLUni::fgDOMWRTFormatPrettyPrint, true ); + + // Write document + m_Serializer->writeNode(myFormTarget, *m_pDomDoc); + } + catch(...) + { + printf( "Can not save output file: %s.", pFileName ); + } + if( myFormTarget ) + delete myFormTarget; //lint !e118 + } + } +} + +// ----------------------------------------------------------------------------- +// CATDataSaver::PrintLinesToScreen +// Prints all saved lines to screen. +// ----------------------------------------------------------------------------- +void CATDataSaver::PrintLinesToScreen( void ) +{ + LOG_FUNC_ENTRY("CATDataSaver::PrintLinesToScreen"); + // Nothing to print? + if( m_vLines.empty() ) + { + printf( "No output data." ); + return; + } + for( int i = 0 ; i < (int)m_vLines.size() ; i++ ) + { + printf( m_vLines[i].c_str() ); + } +} + +// ----------------------------------------------------------------------------- +// CATDataSaver::AddLineToFirst +// Adds saved line to first in database. +// ----------------------------------------------------------------------------- +void CATDataSaver::AddLineToFirst( void ) +{ + LOG_LOW_FUNC_ENTRY("CATDataSaver::AddLineToFirst"); + m_sLine.append( "\n" ); + m_vLines.insert( m_vLines.begin(), m_sLine ); + m_sLine.clear(); +} + +// ----------------------------------------------------------------------------- +// CATDataSaver::AddLineToLast +// Adds saved line to last in database. +// ----------------------------------------------------------------------------- +void CATDataSaver::AddLineToLast() +{ + LOG_LOW_FUNC_ENTRY("CATDataSaver::AddLineToLast"); + m_sLine.append( "\n" ); + + string sTempDataLine; + + m_vLines.push_back( m_sLine ); + + SaveXML( m_sCarbideDataLine, ITEM ); + + if( m_bPrintImmediately ) + { + printf( m_sLine.c_str() ); + } + + m_sCarbideDataLine.clear(); + m_sLine.clear(); +} + +// ----------------------------------------------------------------------------- +// CATDataSaver::AddString +// Adds string to current line. +// ----------------------------------------------------------------------------- +void CATDataSaver::AddString( const char* pData, bool bSaveCarbideData ) +{ + LOG_LOW_FUNC_ENTRY("CATDataSaver::AddString"); + m_sLine.append( pData ); + + if( bSaveCarbideData ) + { + m_sCarbideDataLine.append( pData ); + m_sCarbideDataLine.append(";"); + } +} + +// ----------------------------------------------------------------------------- +// CATDataSaver::AddInteger +// Converts integer to string and adds it to current line. +// ----------------------------------------------------------------------------- +void CATDataSaver::AddInteger( int iValue, bool bSaveCarbideData ) +{ + LOG_LOW_FUNC_ENTRY("CATDataSaver::AddInteger"); + char cTemp[128]; + string sValue( itoa( iValue, cTemp, 10 ) ); + m_sLine.append( sValue ); + + if( bSaveCarbideData ) + { + m_sCarbideDataLine.append( sValue ); + m_sCarbideDataLine.append(";"); + } +} + +// ----------------------------------------------------------------------------- +// CATDataSaver::SetLoggingLevel +// Sets logging level. +// ----------------------------------------------------------------------------- +void CATDataSaver::SetLoggingLevel( int iLoggingLevel ) +{ + LOG_FUNC_ENTRY("CATDataSaver::SetLoggingLevel"); + // Check that new logging level is valid + // Acceptable values are between MIN_LOGGING_LEVEL and + // MAX_LOGGING_LEVEL including them + if( iLoggingLevel >= MIN_LOGGING_LEVEL && iLoggingLevel <= MAX_LOGGING_LEVEL ) + { + m_iLoggingLevel = iLoggingLevel; + } + else + { + // New logging level value is invalid => set default logging level + m_iLoggingLevel = DEFAULT_LOGGING_LEVEL; + } +} + +// ----------------------------------------------------------------------------- +// CATDataSaver::GetLoggingLevel +// Gets logging level. +// ----------------------------------------------------------------------------- +int CATDataSaver::GetLoggingLevel( void ) +{ + LOG_LOW_FUNC_ENTRY("CATDataSaver::GetLoggingLevel"); + return m_iLoggingLevel; +} + +// ----------------------------------------------------------------------------- +// CATDataSaver::SetPrintFlag +// Sets print immediately flag. +// ----------------------------------------------------------------------------- +void CATDataSaver::SetPrintFlag( bool bPrintImmediately ) +{ + LOG_FUNC_ENTRY("CATDataSaver::SetPrintFlag"); + m_bPrintImmediately = bPrintImmediately; +} + +// ----------------------------------------------------------------------------- +// CATDataSaver::SaveCarbideDataHeader +// Sets data header for Carbide data. +// ----------------------------------------------------------------------------- +void CATDataSaver::SaveCarbideDataHeader( void ) +{ + LOG_FUNC_ENTRY("CATDataSaver::SaveCarbideDataHeader"); + SaveXML( m_sCarbideDataLine, LEAK ); + m_sCarbideDataLine.clear(); +} + +// ----------------------------------------------------------------------------- +// CATDataSaver::InitXML +// Initializes xerces xml parser. +// ----------------------------------------------------------------------------- +bool CATDataSaver::InitXML( void ) +{ + LOG_FUNC_ENTRY("CATDataSaver::InitXML"); + try + { + xercesc::XMLPlatformUtils::Initialize(); + } + catch ( ... )//(const XMLException& toCatch) + { + // Do your failure processing here + printf("XML initialization failed.\n"); + return false; + } + // Error code. + int errorCode = 0; + // getDomIMplementation returns null if source has none. + xercesc::DOMImplementation* impl = xercesc::DOMImplementationRegistry::getDOMImplementation(L"Core"); + if (impl != NULL) + { + // Create new DOMWriter. + m_Serializer = ((xercesc::DOMImplementationLS*)impl)->createDOMWriter(); + // New document. + try + { + m_pDomDoc = impl->createDocument( + 0, // Root element namespace URI. + L"results", // Root element name + 0); // Document type object (DTD). + + m_pRootElem = m_pDomDoc->getDocumentElement(); + } + catch (const xercesc::OutOfMemoryException&) + { + XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl; + errorCode = 5; + } + catch (const xercesc::DOMException& e) + { + XERCES_STD_QUALIFIER cerr << "DOMException code is: " << e.code << XERCES_STD_QUALIFIER endl; + errorCode = 2; + } + catch (...) + { + XERCES_STD_QUALIFIER cerr << "An error occurred creating the document" << XERCES_STD_QUALIFIER endl; + errorCode = 3; + } + } // (inpl != NULL) + else + { + XERCES_STD_QUALIFIER cerr << "Requested implementation is not supported" << XERCES_STD_QUALIFIER endl; + errorCode = 4; + } + if( !errorCode ) + { + m_bXMLInitOk = true; + return true; + } + else + { + return false; + } +} + +// ----------------------------------------------------------------------------- +// CATDataSaver::WCharToChar +// Converts wchar_t* -> char*. +// ----------------------------------------------------------------------------- +void CATDataSaver::WCharToChar( string& sInput, const WCHAR* Source ) +{ + LOG_LOW_FUNC_ENTRY("CATDataSaver::WCharToChar"); + if( !Source ) + return; + int i = 0; + + while( Source[i] != '\0' ) + { + char c = (CHAR)Source[i]; + sInput.append( &c, 1 ); + ++i; + } +} + +// ----------------------------------------------------------------------------- +// CATDataSaver::CharToWChar +// Converts char* -> wchar_t*. +// ----------------------------------------------------------------------------- +LPWSTR CATDataSaver::CharToWChar( const char* str ) +{ + LOG_LOW_FUNC_ENTRY("CATDataSaver::CharToWChar"); + LPWSTR out = NULL; + if( str != NULL ) + { + int in_len = (int)strlen( str ); + int out_len = MultiByteToWideChar(CP_ACP, 0, str, in_len, NULL, 0) + 2; + out = new WCHAR[out_len]; + + if (out) + { + memset(out, 0x00, sizeof(WCHAR)*out_len); + MultiByteToWideChar(CP_ACP, 0, str, in_len, out, in_len); + } + } + return out; +} + +// ----------------------------------------------------------------------------- +// CATDataSaver::SaveXML +// Writes data to xml tree. +// ----------------------------------------------------------------------------- +void CATDataSaver::SaveXML( string sInput, int iElementType ) +{ + LOG_FUNC_ENTRY("CATDataSaver::SaveXML"); + // Variables ok? + if( sInput.empty() || m_pDomDoc == NULL ) + { + return; + } + try + { + switch( iElementType ) + { + case RESULT: + { + // Print number of runs + string sTemp = GetStringUntilNextGivenChar( sInput, ';' ); + LPWSTR wTemp = CharToWChar( sTemp.c_str() ); + m_pRootElem->setAttribute( L"runs", (const LPWSTR)wTemp ); + + // Print failed runs + sTemp = GetStringUntilNextGivenChar( sInput, ';' ); + if( wTemp ) + delete[] wTemp; + wTemp = CharToWChar( sTemp.c_str() ); + m_pRootElem->setAttribute( L"failed", (const LPWSTR)wTemp ); + if( wTemp ) + delete[] wTemp; + } + break; + case RUN: + { + if( m_pRootElem == NULL ) + return; + xercesc::DOMElement* runElem = m_pDomDoc->createElement( L"run" ); + m_pRootElem->appendChild( runElem ); + + // Reset handle leaks. + m_pHandleLeaks = NULL; + + // Print start time + string sTemp = GetStringUntilNextGivenChar( sInput, ';' ); + LPWSTR wTemp = CharToWChar( sTemp.c_str() ); + runElem->setAttribute( L"start_time", (const LPWSTR)wTemp ); + runElem->setAttribute( L"end_time", NULL ); + if( wTemp ) + delete[] wTemp; + + // Print build target + sTemp = GetStringUntilNextGivenChar( sInput, ';' ); + wTemp = CharToWChar( sTemp.c_str() ); + runElem->setAttribute( L"build_target", (const LPWSTR)wTemp ); + if( wTemp ) + delete[] wTemp; + + // Print process name + wTemp = CharToWChar( sInput.c_str() ); + runElem->setAttribute( L"process_name", (const LPWSTR)wTemp ); + + m_pRunElement = runElem; + + char cTemp[128]; + if( wTemp ) + delete[] wTemp; + wTemp = CharToWChar( itoa( m_iRunNumber, cTemp, 10 ) ); + runElem->setAttribute( L"id", (const LPWSTR)wTemp ); + m_iRunNumber++; + if( wTemp ) + delete[] wTemp; + } + break; + case LEAK: + { + m_pCurrentLeakElem = m_pDomDoc->createElement( L"leak" ); + + + if( m_pCurrentLeakElem == NULL || m_pRunElement == NULL ) + return; + + // Sub test? + if( m_pCurrentSubTestElem ) + m_pCurrentSubTestElem->appendChild( m_pCurrentLeakElem ); + else + m_pRunElement->appendChild( m_pCurrentLeakElem ); + + // Print leak ID + string sTemp = GetStringUntilNextGivenChar( sInput, ';' ); + LPWSTR wTemp = CharToWChar( sTemp.c_str() ); + m_pCurrentLeakElem->setAttribute( L"id", (const LPWSTR)wTemp ); + + // Print leak size + sTemp = GetStringUntilNextGivenChar( sInput, ';' ); + if( wTemp ) + delete[] wTemp; + wTemp = CharToWChar( sTemp.c_str() ); + m_pCurrentLeakElem->setAttribute( L"size", (const LPWSTR)wTemp ); + + // Print leak address + sTemp = GetStringUntilNextGivenChar( sInput, ';' ); + if( wTemp ) + delete[] wTemp; + wTemp = CharToWChar( sTemp.c_str() ); + m_pCurrentLeakElem->setAttribute( L"memaddress", (const LPWSTR)wTemp ); + + // Print leak time + sTemp = GetStringUntilNextGivenChar( sInput, ';' ); + if( wTemp ) + delete[] wTemp; + wTemp = CharToWChar( sTemp.c_str() ); + m_pCurrentLeakElem->setAttribute( L"time", (const LPWSTR)wTemp ); + + // Print leak module + sTemp = GetStringUntilNextGivenChar( sInput, ';' ); + if( wTemp ) + delete[] wTemp; + wTemp = CharToWChar( sTemp.c_str() ); + m_pCurrentLeakElem->setAttribute( L"module", (const LPWSTR)wTemp ); + if( wTemp ) + delete[] wTemp; + } + break; + case ITEM: + { + xercesc::DOMNode* callstackNode = NULL; + + xercesc::DOMElement* callstackElem = NULL; + + if( m_pCurrentLeakElem == NULL ) + return; + + // Print module name + if( !m_pCurrentLeakElem->hasChildNodes() ) + { + callstackElem = m_pDomDoc->createElement( L"callstack" ); + m_pCurrentLeakElem->appendChild( callstackElem ); + callstackNode = callstackElem; + } + else + { + callstackNode = m_pCurrentLeakElem->getFirstChild(); + } + + // Add callstack item + xercesc::DOMElement* itemElem = m_pDomDoc->createElement( L"item" ); + callstackNode->appendChild( itemElem ); + + // Print memory address name + string sTemp = GetStringUntilNextGivenChar( sInput, ';' ); + LPWSTR wTemp = CharToWChar( sTemp.c_str() ); + + itemElem->setAttribute( L"memaddress", (const LPWSTR)wTemp ); + + // Print calculated memory address + sTemp = GetStringUntilNextGivenChar( sInput, ';' ); + if( wTemp ) + delete[] wTemp; + wTemp = CharToWChar( sTemp.c_str() ); + + itemElem->setAttribute( L"calc_addr", (const LPWSTR)wTemp ); + + // Print module name + sTemp = GetStringUntilNextGivenChar( sInput, ';' ); + if( wTemp ) + delete[] wTemp; + wTemp = CharToWChar( sTemp.c_str() ); + + itemElem->setAttribute( L"module", (const LPWSTR)wTemp ); + + // Print function name + sTemp = GetStringUntilNextGivenChar( sInput, ';' ); + if( wTemp ) + delete[] wTemp; + wTemp = CharToWChar( sTemp.c_str() ); + + itemElem->setAttribute( L"function", (const LPWSTR)wTemp ); + + sTemp = GetStringUntilNextGivenChar( sInput, ';' ); + + // Print function line from urel build + if( !m_bUdebBuild ) + { + if( wTemp ) + delete[] wTemp; + wTemp = CharToWChar( sTemp.c_str() ); + itemElem->setAttribute( L"function_line", (const LPWSTR)wTemp ); + sTemp = GetStringUntilNextGivenChar( sInput, ';' ); + } + + // Print file name + if( wTemp ) + delete[] wTemp; + // Erase if path found from sTemp. + if ( sTemp.rfind( "/" ) != string::npos ) + { + sTemp.erase(0, sTemp.rfind( "/" )+1 ); + } + if ( sTemp.rfind( "\\" ) != string::npos ) + { + sTemp.erase(0, sTemp.rfind( "\\" )+1 ); + } + wTemp = CharToWChar( sTemp.c_str() ); + + itemElem->setAttribute( L"file", (const LPWSTR)wTemp ); + + // Print line of file + sTemp = GetStringUntilNextGivenChar( sInput, ';' ); + if( wTemp ) + delete[] wTemp; + wTemp = CharToWChar( sTemp.c_str() ); + + if( m_bUdebBuild ) + itemElem->setAttribute( L"line", (const LPWSTR)wTemp ); + if( wTemp ) + delete[] wTemp; + } + break; + case RUN_END: + { + if( m_pRunElement == NULL ) + return; + const LPWSTR wTemp = CharToWChar( sInput.c_str() ); + m_pRunElement->setAttribute( L"end_time", wTemp ); + if( wTemp ) + delete[] wTemp; + } + break; + case ERROR_IN_RUN: + { + if( m_pRunElement == NULL ) + return; + // Add error item + xercesc::DOMElement* errorElem = m_pDomDoc->createElement( L"error" ); + m_pRunElement->appendChild( errorElem ); + + // Print error code + string sTemp = GetStringUntilNextGivenChar( sInput, ';' ); + LPWSTR wTemp = CharToWChar( sTemp.c_str() ); + errorElem->setAttribute( L"code", (const LPWSTR)wTemp ); + + // Print error time + sTemp = GetStringUntilNextGivenChar( sInput, ';' ); + if( wTemp ) + delete[] wTemp; + wTemp = CharToWChar( sTemp.c_str() ); + errorElem->setAttribute( L"time", (const LPWSTR)wTemp ); + if( wTemp ) + delete[] wTemp; + } + break; + case MEM_LEAKS: + { + if( m_pRunElement == NULL ) + return; + xercesc::DOMElement* memoryLeaksElement = m_pDomDoc->createElement( L"mem_leaks" ); + m_pRunElement->appendChild( memoryLeaksElement ); + m_pMemoryLeaks = memoryLeaksElement; + + // Print number of leaks + LPWSTR wTemp = CharToWChar( sInput.c_str() ); + memoryLeaksElement->setAttribute( L"count", (const LPWSTR)wTemp ); + if( wTemp ) + delete[] wTemp; + } + break; + case MEM_LEAK_MODULE: + { + if( m_pMemoryLeaks == NULL ) + return; + xercesc::DOMElement* moduleElement = m_pDomDoc->createElement( L"module" ); + m_pMemoryLeaks->appendChild( moduleElement ); + + // Print module name + string sTemp = GetStringUntilNextGivenChar( sInput, ';' ); + LPWSTR wTemp = CharToWChar( sTemp.c_str() ); + moduleElement->setAttribute( L"name", (const LPWSTR)wTemp ); + + if( wTemp ) + delete[] wTemp; + // Print number of memory leaks + wTemp = CharToWChar( sInput.c_str() ); + moduleElement->setAttribute( L"leaks", (const LPWSTR)wTemp ); + if( wTemp ) + delete[] wTemp; + } + break; + case HANDLE_LEAKS: + { + if( m_pRunElement == NULL ) + return; + if( m_pHandleLeaks ) + { + // Update number of leaks + LPWSTR wTemp = CharToWChar( sInput.c_str() ); + m_pHandleLeaks->setAttribute( L"count", (const LPWSTR)wTemp ); + if( wTemp ) + delete[] wTemp; + } + else + { + xercesc::DOMElement* handleLeaksElement = m_pDomDoc->createElement( L"handle_leaks" ); + m_pRunElement->appendChild( handleLeaksElement ); + m_pHandleLeaks = handleLeaksElement; + + // Print number of leaks + LPWSTR wTemp = CharToWChar( sInput.c_str() ); + handleLeaksElement->setAttribute( L"count", (const LPWSTR)wTemp ); + if( wTemp ) + delete[] wTemp; + } + } + break; + case HANDLE_LEAK_MODULE: + { + if( m_pHandleLeaks == NULL ) + return; + xercesc::DOMElement* moduleElement = m_pDomDoc->createElement( L"module" ); + m_pHandleLeaks->appendChild( moduleElement ); + + // Print module name + string sTemp = GetStringUntilNextGivenChar( sInput, ';' ); + LPWSTR wTemp = CharToWChar( sTemp.c_str() ); + moduleElement->setAttribute( L"name", (const LPWSTR)wTemp ); + if( wTemp ) + delete[] wTemp; + + // Print number of memory leaks + wTemp = CharToWChar( sInput.c_str() ); + moduleElement->setAttribute( L"leaks", (const LPWSTR)wTemp ); + if( wTemp ) + delete[] wTemp; + } + break; + case TEST_START: + { + m_pCurrentSubTestElem = m_pDomDoc->createElement( L"subtest" ); + + if( m_pCurrentSubTestElem == NULL || m_pRunElement == NULL ) + return; + + m_pRunElement->appendChild( m_pCurrentSubTestElem ); + + // Print sub test name + string sTemp = GetStringUntilNextGivenChar( sInput, ';' ); + LPWSTR wTemp = CharToWChar( sTemp.c_str() ); + m_pCurrentSubTestElem->setAttribute( L"name", (const LPWSTR)wTemp ); + if( wTemp ) + { + delete[] wTemp; + wTemp = NULL; + } + + // Print sub test time + sTemp = GetStringUntilNextGivenChar( sInput, ';' ); + wTemp = CharToWChar( sTemp.c_str() ); + m_pCurrentSubTestElem->setAttribute( L"start_time", (const LPWSTR)wTemp ); + if( wTemp ) + delete[] wTemp; + break; + } + case TEST_END: + { + if( m_pCurrentSubTestElem == NULL ) + return; + // Print end time + string sTemp = GetStringUntilNextGivenChar( sInput, ';' ); + LPWSTR wTemp = CharToWChar( sTemp.c_str() ); + m_pCurrentSubTestElem->setAttribute( L"end_time", (const LPWSTR)wTemp ); + m_pCurrentSubTestElem = NULL; + if( wTemp ) + delete[] wTemp; + break; + } + case SUBTEST_MEM_LEAKS: + { + if( m_pCurrentSubTestElem == NULL ) + return; + xercesc::DOMElement* memoryLeaksElement = m_pDomDoc->createElement( L"mem_leaks" ); + m_pCurrentSubTestElem->appendChild( memoryLeaksElement ); + m_pSubtestMemoryLeaks = memoryLeaksElement; + + // Print number of leaks + LPWSTR wTemp = CharToWChar( sInput.c_str() ); + memoryLeaksElement->setAttribute( L"count", (const LPWSTR)wTemp ); + if( wTemp ) + delete[] wTemp; + break; + } + case SUBTEST_MEM_LEAK_MODULE: + { + if( m_pSubtestMemoryLeaks == NULL ) + return; + xercesc::DOMElement* moduleElement = m_pDomDoc->createElement( L"module" ); + m_pSubtestMemoryLeaks->appendChild( moduleElement ); + + // Print module name + string sTemp = GetStringUntilNextGivenChar( sInput, ';' ); + LPWSTR wTemp = CharToWChar( sTemp.c_str() ); + moduleElement->setAttribute( L"name", (const LPWSTR)wTemp ); + + if( wTemp ) + delete[] wTemp; + // Print number of memory leaks + wTemp = CharToWChar( sInput.c_str() ); + moduleElement->setAttribute( L"leaks", (const LPWSTR)wTemp ); + if( wTemp ) + delete[] wTemp; + break; + } + case SUBTEST_HANDLE_LEAKS: + { + if( m_pCurrentSubTestElem == NULL ) + return; + xercesc::DOMElement* handleLeaksElement = m_pDomDoc->createElement( L"handle_leaks" ); + m_pCurrentSubTestElem->appendChild( handleLeaksElement ); + + //Print number of handle leaks + string sTemp = GetStringUntilNextGivenChar( sInput, ';' ); + LPWSTR wTemp = CharToWChar( sTemp.c_str() ); + handleLeaksElement->setAttribute( L"count", (const LPWSTR)wTemp ); + if( wTemp ) + delete[] wTemp; + break; + } + default: + break; + } + } + catch( ... ) + { + printf( "Error when writing data to XML file." ); + } +} + +// ----------------------------------------------------------------------------- +// CATDataSaver::GetStringUntilNextGivenChar +// Function returns string from begin of given string until next given char, +// characters until given char are removed from sInput string. +// ----------------------------------------------------------------------------- +string CATDataSaver::GetStringUntilNextGivenChar( string& sInput, char cCharacter ) +{ + LOG_LOW_FUNC_ENTRY("CATDataSaver::GetStringUntilNextGivenChar"); + string sRet; + size_t iPos = sInput.find( cCharacter ); + if( sInput.size() > 1 && iPos != string::npos ) + { + sRet = sInput.substr( 0, iPos ); + sInput.erase( 0, (iPos + 1) ); + } + return sRet; +} + +// ----------------------------------------------------------------------------- +// CATDataSaver::SetBuild +// Function sets build target info. +// ----------------------------------------------------------------------------- +void CATDataSaver::SetBuild( bool bUdebBuild ) +{ + LOG_FUNC_ENTRY("CATDataSaver::SetBuild"); + m_bUdebBuild = bUdebBuild; +} + +// ----------------------------------------------------------------------------- +// CATDataSaver::AddCarbideData +// Function adds string to Carbide data. +// ----------------------------------------------------------------------------- +void CATDataSaver::AddCarbideData( const string& sInput ) +{ + LOG_LOW_FUNC_ENTRY("CATDataSaver::AddCarbideData"); + m_sCarbideDataLine.append( sInput ); + m_sCarbideDataLine.append(";"); +} + +// ----------------------------------------------------------------------------- +// CATDataSaver::IntegerToString +// Converts integer to string. +// ----------------------------------------------------------------------------- +string CATDataSaver::IntegerToString( int iValueToConvert ) +{ + LOG_LOW_FUNC_ENTRY("CATDataSaver::IntegerToString"); + char cTemp[128]; + string sValue( itoa( iValueToConvert, cTemp, 10 ) ); + return sValue; +} diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/src/CATMemoryAddress.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/src/CATMemoryAddress.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,307 @@ +/* +* 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: Class representing a memory address and its details. +* +*/ + + +#include "../inc/CATMemoryAddress.h" +#include "../inc/CATBase.h" + +// ----------------------------------------------------------------------------- +// CATMemoryAddress::CATMemoryAddress +// Constructor +// ----------------------------------------------------------------------------- +CATMemoryAddress::CATMemoryAddress(string& sAddress, unsigned long iOffSet) +{ + LOG_LOW_FUNC_ENTRY("CATMemoryAddress::CATMemoryAddress"); + m_sAddress = sAddress; + m_sFileName = ""; + m_sFunctionName = ""; + m_sModuleName = ""; + m_iAddress = CATBase::_httoi( sAddress.c_str() ); + m_iDllLoadinfoIndex = -1; + m_iModuleStartAddress = 0; + m_iOffSetFromModuleStart = 0; + m_iExactLineNumber = -1; + m_iFunctionLineNumber = -1; + m_ePinPointState = OUT_OF_PROCESS; + m_iOffSet = iOffSet; +} + +// ----------------------------------------------------------------------------- +// CATMemoryAddress::~CATMemoryAddress +// Destructor. +// ----------------------------------------------------------------------------- +CATMemoryAddress::~CATMemoryAddress() +{ + LOG_LOW_FUNC_ENTRY("CATMemoryAddress::~CATMemoryAddress"); +} + +// ----------------------------------------------------------------------------- +// CATMemoryAddress::FindSetModuleName +// Find which binary this address belongs to. +// Sets also the offsetfrommodulestart. +// ----------------------------------------------------------------------------- +bool CATMemoryAddress::FindSetModuleName(vector* vDlls) +{ + LOG_LOW_FUNC_ENTRY("CATMemoryAddress::FindSetModuleName"); + vector::iterator it; + for ( it = vDlls->begin() ; + it != vDlls->end(); it++ ) + { + // Is modules load time defined? + if ( (*it).iLoadTime > 0 ) + { + // Check that load time is earlier or same as allocation + if ( m_iTime >= (*it).iLoadTime + && m_iAddress >= (*it).iStartAddress + && m_iAddress < (*it).iEndAddress ) + { + // Module is loaded until process end. + if ( (*it).iUnloadTime == 0 ) + break; + // Check is allocation done before module was unloaded. + else if ( (*it).iUnloadTime >= m_iTime ) + break; + } + } + // Module has no time defined use only code segments. + else + { + if ( m_iAddress >= (*it).iStartAddress + && m_iAddress < (*it).iEndAddress ) + break; + } + } + + // Did we not find module where address is? + if ( it == vDlls->end() ) + return false; + + m_ePinPointState = OUT_OF_RANGE; + m_sModuleName = (*it).sModuleName; + m_iModuleStartAddress = (*it).iStartAddress; + m_iOffSetFromModuleStart = m_iAddress - m_iModuleStartAddress; + m_iOffSetFromModuleStart += m_iOffSet; + m_iDllLoadinfoIndex = distance( vDlls->begin(), it ) ; + return true; +} + +// ----------------------------------------------------------------------------- +// CATMemoryAddress::SetModuleStartAddress +// Set start address of the binary in which address resides. +// Note, this also sets the offset from start value. +// ----------------------------------------------------------------------------- +void CATMemoryAddress::SetModuleStartAddress(unsigned long iAddress) +{ + LOG_LOW_FUNC_ENTRY("CATMemoryAddress::SetModuleStartAddress"); + m_iModuleStartAddress = iAddress; + m_iOffSetFromModuleStart = m_iAddress - m_iModuleStartAddress; + m_iOffSetFromModuleStart += m_iOffSet; +} + + +// ----------------------------------------------------------------------------- +// CATMemoryAddress::GetOffSetFromModuleStart +// Note return value includes the set offset. +// So this value is not binary start - address. +// Instead it is. +// memory address - binary start address + offset +// ----------------------------------------------------------------------------- +unsigned long CATMemoryAddress::GetOffSetFromModuleStart() +{ + LOG_LOW_FUNC_ENTRY("CATMemoryAddress::GetOffSetFromModuleStart"); + return m_iOffSetFromModuleStart; +} + +int CATMemoryAddress::GetDllLoadInfoIndex() +{ + LOG_LOW_FUNC_ENTRY("CATMemoryAddress::GetDllLoadInfo"); + return m_iDllLoadinfoIndex; +} + +// ----------------------------------------------------------------------------- +// CATMemoryAddress::SetTime +// ----------------------------------------------------------------------------- +void CATMemoryAddress::SetTime( unsigned long long& ullTime ) +{ + LOG_LOW_FUNC_ENTRY("CATMemoryAddress::SetTime"); + m_iTime = ullTime; +} + +// ----------------------------------------------------------------------------- +// CATMemoryAddress::GetTIme +// ----------------------------------------------------------------------------- +unsigned long long CATMemoryAddress::GetTime() +{ + LOG_LOW_FUNC_ENTRY("CATMemoryAddress::GetTime"); + return m_iTime; +} + +// ----------------------------------------------------------------------------- +// CATMemoryAddress::SetAddress +// ----------------------------------------------------------------------------- +void CATMemoryAddress::SetAddress(string& sAddress) +{ + LOG_LOW_FUNC_ENTRY("CATMemoryAddress::SetAddress"); + m_sAddress = sAddress; + m_iAddress = CATBase::_httoi( sAddress.c_str() ); +} + +// ----------------------------------------------------------------------------- +// CATMemoryAddress::GetAddressString +// ----------------------------------------------------------------------------- +string CATMemoryAddress::GetAddressString() +{ + LOG_LOW_FUNC_ENTRY("CATMemoryAddress::GetAddressString"); + return m_sAddress; +} + +// ----------------------------------------------------------------------------- +// CATMemoryAddress::SetAddress +// ----------------------------------------------------------------------------- +void CATMemoryAddress::SetAddress(unsigned long iAddress) +{ + LOG_LOW_FUNC_ENTRY("CATMemoryAddress::SetAddress"); + m_iAddress = iAddress; +} + +// ----------------------------------------------------------------------------- +// CATMemoryAddress::GetAddress +// ----------------------------------------------------------------------------- +unsigned long CATMemoryAddress::GetAddress() +{ + LOG_LOW_FUNC_ENTRY("CATMemoryAddress::GetAddress"); + return m_iAddress; +} + +// ----------------------------------------------------------------------------- +// CATMemoryAddress::SetModuleName +// ----------------------------------------------------------------------------- +void CATMemoryAddress::SetModuleName(string& sModuleName) +{ + LOG_LOW_FUNC_ENTRY("CATMemoryAddress::SetModuleName"); + m_sModuleName = sModuleName; +} + +// ----------------------------------------------------------------------------- +// CATMemoryAddress::GetModuleName +// ----------------------------------------------------------------------------- +string CATMemoryAddress::GetModuleName() +{ + LOG_LOW_FUNC_ENTRY("CATMemoryAddress::GetModuleName"); + return m_sModuleName; +} + +// ----------------------------------------------------------------------------- +// CATMemoryAddress::SetAddressToLineState +// ----------------------------------------------------------------------------- +void CATMemoryAddress::SetAddressToLineState( ADDRESS_TO_LINE_STATE eState ) +{ + LOG_LOW_FUNC_ENTRY("CATMemoryAddress::SetAddressToLineState"); + m_ePinPointState = eState; +} + +// ----------------------------------------------------------------------------- +// CATMemoryAddress::GetAddressToLineState +// ----------------------------------------------------------------------------- +int CATMemoryAddress::GetAddressToLineState() +{ + LOG_LOW_FUNC_ENTRY("CATMemoryAddress::GetAddressToLineState"); + return m_ePinPointState; +} + +// ----------------------------------------------------------------------------- +// CATMemoryAddress::SetFileName +// ----------------------------------------------------------------------------- +void CATMemoryAddress::SetFileName(string& sFileName) +{ + LOG_LOW_FUNC_ENTRY("CATMemoryAddress::SetFileName"); + m_sFileName = sFileName; +} + +// ----------------------------------------------------------------------------- +// CATMemoryAddress::GetFileName +// ----------------------------------------------------------------------------- +string CATMemoryAddress::GetFileName() +{ + LOG_LOW_FUNC_ENTRY("CATMemoryAddress::GetFileName"); + return m_sFileName; +} + +// ----------------------------------------------------------------------------- +// CATMemoryAddress::SetFunctionName +// ----------------------------------------------------------------------------- +void CATMemoryAddress::SetFunctionName(string& sFunctionName) +{ + LOG_LOW_FUNC_ENTRY("CATMemoryAddress::SetFunctionName"); + m_sFunctionName = sFunctionName; +} + +// ----------------------------------------------------------------------------- +// CATMemoryAddress::GetFunctionName +// ----------------------------------------------------------------------------- +string CATMemoryAddress::GetFunctionName() +{ + LOG_LOW_FUNC_ENTRY("CATMemoryAddress::GetFunctionName"); + return m_sFunctionName; +} + +// ----------------------------------------------------------------------------- +// CATMemoryAddress::SetFunctionLineNumber +// ----------------------------------------------------------------------------- +void CATMemoryAddress::SetFunctionLineNumber(int iFunctionLineNumber) +{ + LOG_LOW_FUNC_ENTRY("CATMemoryAddress::SetFunctionLineNumber"); + m_iFunctionLineNumber = iFunctionLineNumber; +} + +// ----------------------------------------------------------------------------- +// CATMemoryAddress::GetFunctionLineNumber +// ----------------------------------------------------------------------------- +int CATMemoryAddress::GetFunctionLineNumber() +{ + LOG_LOW_FUNC_ENTRY("CATMemoryAddress::GetFunctionLineNumber"); + return m_iFunctionLineNumber; +} + +// ----------------------------------------------------------------------------- +// CATMemoryAddress::SetExactLineNumber +// ----------------------------------------------------------------------------- +void CATMemoryAddress::SetExactLineNumber(int iExactLineNumber) +{ + LOG_LOW_FUNC_ENTRY("CATMemoryAddress::SetExactLineNumber"); + m_iExactLineNumber = iExactLineNumber; +} + +// ----------------------------------------------------------------------------- +// CATMemoryAddress::GetExactLineNumber +// ----------------------------------------------------------------------------- +int CATMemoryAddress::GetExactLineNumber() +{ + LOG_LOW_FUNC_ENTRY("CATMemoryAddress::GetExactLineNumber"); + return m_iExactLineNumber; +} + +// ----------------------------------------------------------------------------- +// CATMemoryAddress::GetModuleStartAddress +// ----------------------------------------------------------------------------- +unsigned long CATMemoryAddress::GetModuleStartAddress() const +{ + LOG_LOW_FUNC_ENTRY("CATMemoryAddress::GetModuleStartAddress"); + return m_iModuleStartAddress; +} + +//EOF diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/src/CATMmp.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/src/CATMmp.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,396 @@ +/* +* 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: Class responsible of handling mmp files. +* +*/ + + +#include "../inc/CATMmp.h" + +CATMmp::CATMmp() +{ + LOG_FUNC_ENTRY("CATMmp::CATMmp"); +} + +CATMmp::~CATMmp() +{ + LOG_FUNC_ENTRY("CATMmp::~CATMmp"); +} + +// ----------------------------------------------------------------------------- +// CATMmp::IsMmpEdited +// Checks is the file edited by AT +// ----------------------------------------------------------------------------- +bool CATMmp::IsMmpEdited( bool bBackup) +{ + LOG_FUNC_ENTRY("CATMmp::IsMmpEdited"); + // Stream to read file + ifstream in; + // Temp char array to read line + char cTemp[MAX_LINE_LENGTH]; + // Open file + if ( bBackup ) + in.open( CreateMmpBackupPath().c_str() ); + else + in.open( m_sMmpFile.c_str() ); + // Is file open ok + if( ! in.good() ) + { + cout << AT_MSG << "Error, can not open file " + << m_sMmpFile << endl; + in.close(); + return false; + } + // Search edit start line + bool bEdited=false; + const char* cFind = MMPFILECHANGES[0].c_str(); + while( ! bEdited && in.good() ) + { + // Get line + in.getline( cTemp, MAX_LINE_LENGTH ); + // Compare to first line in changes + if ( strstr( cTemp, cFind) ) + { + bEdited = true; + // Stop looking any further + break; + } + } + // Close file and return result + in.close(); + return bEdited; +} + +// ----------------------------------------------------------------------------- +// CATMmp::EditMmpFile +// Makes AnalyzeTool changes to given mmp file +// ----------------------------------------------------------------------------- +bool CATMmp::EditMmpFile(const string& sTargetType, const string& sId) +{ + LOG_FUNC_ENTRY("CATMmp::EditMmpFile"); + + if ( ! RemoveWriteProtections() ) + return false; + + // Stream where to add changes + ofstream out; + + // Open mmp file for editing (append changes to the end) + out.open( m_sMmpFile.c_str(), ios::out | ios::app ); + + // File open ok? + if( !out.good() ) + { + cout << AT_MSG << "Error, can not open file " + << m_sMmpFile; + out.close(); + return false; + } + + // Write lines to mmp file + if ( sTargetType.compare( "dll" ) == 0 || sTargetType.compare( "lib" ) == 0 ) + { + // DLL changes + int size = sizeof( MMPFILECHANGES_DLL ) / sizeof( string ); + for( int i = 0; i < size; i++ ) + { + out << endl << MMPFILECHANGES_DLL[i]; + } + out << endl; + } + else + { + // Other than DLL changes + int size = sizeof( MMPFILECHANGES ) / sizeof( string ); + for( int i = 0; i < size; i++ ) + { + // After second line of changes add also source statement + out << endl << MMPFILECHANGES[i]; + if ( i == 1 ) + { + out << endl + << "SOURCE " + << AT_TEMP_CPP_LOWER_START + << sId + << AT_TEMP_CPP_LOWER_END; + } + } + out << endl; + } + // Close stream + out.close(); + + cout << AT_MSG << "Mmp file : " << m_sMmpFile << " edited." << endl; + + return true; +} + +// ----------------------------------------------------------------------------- +// CATMmp::BackupMmpFile +// Backups the mmp file to path/atool_temp/filename.mmp.tmp +// Calling this function results always to +// - none edited mmp +// - none edited backup +// - If mmp is write protected. Create writable copy from it. Backup the write +// procted one. +// ----------------------------------------------------------------------------- +bool CATMmp::BackupMmpFile( ) +{ + LOG_FUNC_ENTRY("CATMmp::BackupMmpFile"); + + if ( ! RemoveWriteProtections() ) + return false; + + // Backup path+filename + string sBackup = CreateMmpBackupPath(); + + // Backup mmp. + if ( CopyFile( m_sMmpFile.c_str() , sBackup.c_str(), false ) == 0 ) + { + // Log and return false if failed to copy file + LOG_STRING( "error copyfile " << m_sMmpFile << " to " << sBackup ); + return false; + } + + // If backup now edited remove changes from it. + if ( IsMmpEdited( true ) ) + { + if ( ! RemoveMmpFileChanges( true ) ) + return false; + } + + return true; +} +// ----------------------------------------------------------------------------- +// CATMmp::RestoreMmpFile +// Restores the mmp file from backup +// ----------------------------------------------------------------------------- +bool CATMmp::RestoreMmpFile() +{ + LOG_FUNC_ENTRY("CATMmp::RestoreMmpFile"); + + if ( ! RemoveWriteProtections() ) + return false; + + if ( CopyFile( CreateMmpBackupPath().c_str() , m_sMmpFile.c_str(), false ) == 0 ) + { + // Log and return false if failed to copy file + LOG_STRING("error copyfile " << CreateMmpBackupPath() << " to " << m_sMmpFile ); + return false; + } + else + cout << AT_MSG << "Mmp file : " << m_sMmpFile << " restored." << endl; + return true; +} + +// ----------------------------------------------------------------------------- +// CATMmp::RemoveMmpFileChanges +// Removes AT changes from given mmp file +// ----------------------------------------------------------------------------- +bool CATMmp::RemoveMmpFileChanges(bool bBackup) +{ + LOG_FUNC_ENTRY("CATMmp::RemoveMmpFileChanges"); + + if ( ! RemoveWriteProtections() ) + return false; + + // File reading stream + ifstream in; + // Vector to hold file data + vector vLines; + // Open file + if ( bBackup ) + in.open( CreateMmpBackupPath().c_str(), ios::in ); + else + in.open( m_sMmpFile.c_str(), ios::in ); + // Check file open ok + if ( ! in.good() ) + { + cout << AT_MSG << "Error, opening file"; + if ( bBackup ) + cout << CreateMmpBackupPath(); + else + cout << m_sMmpFile; + cout << endl; + return false; + } + // Read file to temporary stream except AT changes + char cLine[MAX_LINE_LENGTH]; + // Boolean to know read or not + bool bRead = true; + // Integer to confirm that AT changes were succefully found and + // not read even if they are found multiple times + int iSuccessfull = 0; + // Number of 'lines' in mmp changes + int iChangesSize = sizeof( MMPFILECHANGES ) / sizeof( string ); + // First mmp changes line + string sFirstLine = MMPFILECHANGES[0]; + // Last mmp changes line + string sLastLine = MMPFILECHANGES[iChangesSize-1]; + while( in.good() ) + { + in.getline( cLine, MAX_LINE_LENGTH ); + // Check start of AT changes + if( strstr( cLine, sFirstLine.c_str() ) != 0 ) + { + // Remove last linefeed + vector::iterator it = vLines.end(); + it--; + if ( it->size() == 0 ) + vLines.erase( vLines.end()-1, vLines.end() ); + // Stop reading + bRead = false; + iSuccessfull+=3; + } + // Read lines outside AT changes + if ( bRead ) + { + // Gather all other lines except the AT edits + vLines.push_back( string(cLine) ); + } + // Check end of AT changes + if( strstr( cLine, sLastLine.c_str() ) != 0 ) + { + // Get empty line + in.getline( cLine, MAX_LINE_LENGTH ); + // Continue reading + bRead = true; + iSuccessfull-=1; + } + } + // Close reading file stream + in.close(); + // To check all went ok iSuccesfull%2 = 0 + if ( iSuccessfull%2 != 0 && iSuccessfull >= 2 ) + { + cout << AT_MSG << "Error, removing mmp changes from "; + if ( bBackup ) + cout << CreateMmpBackupPath(); + else + cout << m_sMmpFile; + cout << endl; + return false; + } + // Overwrite current mmp file + ofstream out; + // Open file (truncates old data) + if ( bBackup ) + out.open( CreateMmpBackupPath().c_str(), ios::trunc ); + else + out.open( m_sMmpFile.c_str(), ios::trunc ); + // Is open ok + if( ! out.good() ) + { + cout << AT_MSG << "Error, opening file "; + if ( bBackup ) + cout << CreateMmpBackupPath(); + else + cout << m_sMmpFile; + cout << endl; + } + // Write lines to file + for( vector::iterator it = vLines.begin() ; it != vLines.end() ; it++ ) + { + out << *it << endl; + } + // Close + out.close(); + // Return true + return true; +} +// ----------------------------------------------------------------------------- +// CATMmp::VerifyAndRecover +// Wont change mmp if it is not edited +// Replaces mmp file using backup if it exists and it is +// not edited otherwise removes changes from mmp file. +// ----------------------------------------------------------------------------- +bool CATMmp::VerifyAndRecover() +{ + LOG_FUNC_ENTRY("CATMmp::VerifyAndRecover"); + // Is it edited + if ( IsMmpEdited() ) + { + string sBackup = CreateMmpBackupPath(); + if ( FileExists( sBackup.c_str() ) ) + { + // Is backup edited + if ( ! IsMmpEdited( true ) ) + { + // Replace original with backup + return RestoreMmpFile(); + } + } + // Remove changes from original + return RemoveMmpFileChanges(); + } + // Non edited original + return true; +} + +// ----------------------------------------------------------------------------- +// CATMmp::CreateMmpBackupPath +// Creates string containing full path to backup mmp file +// ----------------------------------------------------------------------------- +string CATMmp::CreateMmpBackupPath() +{ + LOG_FUNC_ENTRY("CATMmp::CreateMmpBackupPath"); + // backup path+filename + string sBackup; + sBackup.append( GetPathOrFileName( false, m_sMmpFile ) ); + sBackup.append( AT_TEMP_DIR ); + sBackup.append( "\\" ); + // Add mmp file name to it and .tmp + sBackup.append( GetPathOrFileName( true, m_sMmpFile ) ); + // Add .tmp + sBackup.append( ".tmp" ); + // Return it + return sBackup; +} + +// ----------------------------------------------------------------------------- +// CATMmp::RemoveWriteProtections +// Removes write protection of mmp file and backup if exists. +// ----------------------------------------------------------------------------- +bool CATMmp::RemoveWriteProtections() +{ + LOG_LOW_FUNC_ENTRY("CATMmp::RemoveWriteProtections"); + + // Backup path+filename + string sBackup = CreateMmpBackupPath(); + + // Check is mmp read-only + if ( IsFileReadOnly( m_sMmpFile.c_str() ) ) + { + if( ! SetFileWritable( m_sMmpFile.c_str() ) ) + { + LOG_STRING( "error setting mmp file writable" << m_sMmpFile ); + return false; + } + } + + // Check is there a backup if is remove any write protection from it. + if ( FileExists( sBackup.c_str() ) ) + { + if ( IsFileReadOnly( sBackup.c_str() ) ) + { + if( ! SetFileWritable( sBackup.c_str() ) ) + { + LOG_STRING( "error setting mmp file writable" << sBackup ); + return false; + } + } + } + return true; +} +// End of file diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/src/CATModule2.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/src/CATModule2.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,1634 @@ +/* +* 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: Class representing a module in project (sbs2) +* +*/ + + +#include "../inc/CATModule2.h" +#include "../inc/CATProject.h" +#include "../inc/CATDatParser.h" +#include "../inc/CATMemoryAddress.h" +#include "../inc/catdbghelper.h" +#include "../inc/cataddr2line.h" + +CATModule2::CATModule2(void) +{ + LOG_FUNC_ENTRY("CATModule2::CATModule2"); + m_bAddressToLineInitialized = false; + m_pAddressToLine = 0; + m_sErrors = ""; + m_sMakeFile = ""; + m_eBuildSystem = CATProject::SBS_V1; + m_sCompileInfoText = ""; +} + +CATModule2::~CATModule2(void) +{ + LOG_FUNC_ENTRY("CATModule2::~CATModule2"); + if ( m_pAddressToLine ) + m_pAddressToLine->Close(); + delete m_pAddressToLine; +} + +bool CATModule2::AddressToLine( CATMemoryAddress* pMemoryAddress ) +{ + LOG_FUNC_ENTRY("CATModule2::AddressToLine"); + if ( _stricmp( m_sVariantPlatform.c_str(), "winscw" ) == 0 ) + { + return AddressToLineWinscw( pMemoryAddress ); + } + else if ( _stricmp( m_sVariantPlatform.c_str(), "armv5" ) == 0 ) + { + // addr2line exe. + #ifdef ADDR2LINE + return AddressToLineAddr2lineExe( pMemoryAddress ); + #endif + // lst and map files. + #ifndef ADDR2LINE + return AddressToLineArmv5( pMemoryAddress ); + #endif + } + else if ( _stricmp( m_sVariantPlatform.c_str(), "gcce" ) == 0 ) + { + return AddressToLineAddr2lineExe( pMemoryAddress ); + } + return false; +} + +bool CATModule2::AddressToLineWinscw( CATMemoryAddress* pMemoryAddress ) +{ + LOG_FUNC_ENTRY("CATModule2::AddressToLineWinscw( CATMemoryAddress* pMemoryAddress )"); + if ( m_pAddressToLine == 0 && ! m_bAddressToLineInitialized ) + { + // Use debug helper to locate codelines on winscw platform. + m_pAddressToLine = new CATDbgHelper(); + + // Create full path to binary which we open using CATDbgHelper. + string sFullPathToBinary = GetBinaryFile(); + + // If opening of binary not succesfull set return value to false. + if ( ! m_pAddressToLine->Open( sFullPathToBinary, pMemoryAddress->GetModuleStartAddress() ) ) + { + LOG_STRING("Error, m_pAddressToLine->Open()"); + return false; + } + m_bAddressToLineInitialized = true; + } + // Check pointer before calling. + if ( m_pAddressToLine == 0 ) + return false; + m_pAddressToLine->AddressToLine( pMemoryAddress ); + return true; +} + +bool CATModule2::AddressToLineArmv5( CATMemoryAddress* pMemoryAddress ) +{ + LOG_FUNC_ENTRY("CATModule2::AddressToLine( CATMemoryAddress* pMemoryAddress )"); + if ( ! m_bAddressToLineInitialized ) + return false; + // Find from map file + int iMapIndex = GetSymbolIndexUsingAddress( pMemoryAddress->GetOffSetFromModuleStart() ); + if ( iMapIndex == -1 ) + { + pMemoryAddress->SetAddressToLineState( CATMemoryAddress::OUT_OF_RANGE ); + return true; + } + // Set symbol name + string sSymbolName = m_vMapFileFuncList.at( iMapIndex ).sFunctionName; + + // Remove (... from symbol name + string sSymbolNameRefined( sSymbolName ); + size_t iPos = sSymbolNameRefined.find( "(" ); + if ( iPos != string::npos ) + sSymbolNameRefined.resize( iPos ); + + // Set symbol name as function name for memory address + pMemoryAddress->SetFunctionName( sSymbolNameRefined ); + + // Set state to symbol + pMemoryAddress->SetAddressToLineState( CATMemoryAddress::SYMBOL ); + + // Offset from function start addr + int iOffSetFromFuncStart = pMemoryAddress->GetOffSetFromModuleStart() + - m_vMapFileFuncList.at( iMapIndex ).iAddress; + + // Find from lst list + int iLstIndex = GetLineInFileIndexUsingSymbolName( sSymbolName ); + if ( iLstIndex == -1 ) + return true; + + // Set pinpointing + int iFuncLineNumber = m_vLineInFile.at( iLstIndex ).iLine; + string sFileName = m_vLineInFile.at( iLstIndex ).sFileName; + string sLstFileName = m_vLineInFile.at( iLstIndex ).sLstName; + + pMemoryAddress->SetFunctionLineNumber( iFuncLineNumber ); + pMemoryAddress->SetFileName( sFileName ); + + pMemoryAddress->SetAddressToLineState( CATMemoryAddress::FUNCTION ); + + // In urel mode don't get exact code line + if ( ! IsUDEB() ) + return true; + + // Next calculate the code line inside function + int iExactLineNumber = FindLeakCodeLine( sLstFileName, iFuncLineNumber, iOffSetFromFuncStart ); + pMemoryAddress->SetExactLineNumber( iExactLineNumber ); + + // State is now exact + pMemoryAddress->SetAddressToLineState( CATMemoryAddress::EXACT ); + return true; +} + +bool CATModule2::AddressToLineAddr2lineExe( CATMemoryAddress* pMemoryAddress ) +{ + LOG_FUNC_ENTRY("CATModule2::AddressToLineAddr2lineExe( CATMemoryAddress* pMemoryAddress )"); + if ( m_pAddressToLine == 0 && ! m_bAddressToLineInitialized ) + { + // Use addr2line.exe to locate codelines on armv5 and gcce platform. + m_pAddressToLine = new CATAddr2line(); + + // Create full path to binary .sym file which we open using addr2line.exe. + string sFullPathToBinary = GetBinaryFile(); + + // If opening of binary not succesfull set return value to false. + if ( ! m_pAddressToLine->Open( sFullPathToBinary, pMemoryAddress->GetModuleStartAddress() ) ) + { + LOG_STRING("Error, m_pAddressToLine->Open()"); + return false; + } + m_bAddressToLineInitialized = true; + } + // Check pointer before calling. + if ( m_pAddressToLine == 0 ) + return false; + + m_pAddressToLine->AddressToLine( pMemoryAddress ); + return true; +} + +// Find symbol of given address +int CATModule2::GetSymbolIndexUsingAddress( unsigned long iAddress ) const +{ + LOG_LOW_FUNC_ENTRY("CATModule2::GetSymbolIndexUsingAddress"); + for( size_t i = 0; i < m_vMapFileFuncList.size(); i++ ) + { + unsigned long iStart = m_vMapFileFuncList.at( i ).iAddress; + unsigned long iEnd = ( m_vMapFileFuncList.at( i ).iAddress + + m_vMapFileFuncList.at( i ).iFuncLength ); + + if ( iAddress >= iStart && iAddress < iEnd ) + return (int) i; + } + return -1; +} + +// Find index of function line in file vector of given symbolname +int CATModule2::GetLineInFileIndexUsingSymbolName( const string& sSymbolName ) const +{ + LOG_LOW_FUNC_ENTRY("CATModule2::GetLineInFileIndexUsingSymbolName"); + for( size_t i = 0; i < m_vLineInFile.size(); i++ ) + { + string sLineInFileName = m_vLineInFile.at( i ).sFunction; + if( sLineInFileName.find( sSymbolName ) != string::npos ) + { + return (int) i; + } + } + return -1; +} + + +// Check does modules symbol file(s) exist. +bool CATModule2::SymbolFileExist( void ) +{ + LOG_FUNC_ENTRY("CATModule2::SymbolFileExist"); + string sFullPathToSym = GetSymbolFile(); + if ( !FileExists( sFullPathToSym.c_str() ) ) + { + // Add missing symbol file to error string. + m_sErrors.append( "Missing symbol file: " ); + m_sErrors.append( sFullPathToSym ); + m_sErrors.append( "\n" ); + return false; + } + return true; +} + +// Check does modules map file(s) exists. +bool CATModule2::MapFileExist( void ) +{ + LOG_FUNC_ENTRY("CATModule2::MapFileExist"); + string sFullPathToMap = GetMapFile(); + if ( !FileExists( sFullPathToMap.c_str() ) ) + { + // Add missing symbol file to error string. + m_sErrors.append( "Missing map file: " ); + m_sErrors.append( sFullPathToMap ); + m_sErrors.append( "\n" ); + return false; + } + return true; +} + +//Check does modules binary file(s) exist. +bool CATModule2::BinaryFileExist( void ) +{ + LOG_FUNC_ENTRY("CATModule2::BinaryFileExist"); + string sFullPathToBinary = GetBinaryFile(); + if ( ! FileExists( sFullPathToBinary.c_str() ) ) + { + // Add missing binary to error string. + m_sErrors.append( "Missing binary file: " ); + m_sErrors.append( sFullPathToBinary ); + m_sErrors.append( "\n" ); + return false; + } + return true; +} + +void CATModule2::AddSource(const string &sSourceFile, const string& sLstFile) +{ + LOG_LOW_FUNC_ENTRY("CATModule2::AddSource"); + // Parse sources which are separated by spaces + if( sSourceFile.length() < 1 || sLstFile.length() < 1 ) + return; + + // Skip if its temporary cpp. + if ( sSourceFile.find( AT_TEMP_CPP_LOWER_START) != string::npos ) + return; + + // Source structure + SOURCE sNew; + sNew.sCpp = sSourceFile; + sNew.sLst = sLstFile; + + // Verify paths. + ConvertUnixPathToWin( sNew.sCpp ); + ConvertUnixPathToWin( sNew.sLst ); + + // Lower case them. + ChangeToLower( sNew.sCpp ); + ChangeToLower( sNew.sLst ); + + // Add it + m_vSources.push_back( sNew ); +} + +void CATModule2::AddSources(string& sSource) +{ + LOG_LOW_FUNC_ENTRY("CATModule2::AddSources"); + // Parse sources which are separated by spaces + if( sSource.length() < 1 ) + return; + // Source structure + SOURCE sNew; + size_t iSpot = string::npos; + iSpot = sSource.find( " " ); + while( iSpot != string::npos ) + { + // Pickup source + sNew.sCpp = sSource.substr(0, iSpot); + // Convert path from Unix to Win + ConvertUnixPathToWin( sNew.sCpp ); + // Lowercase it + ChangeToLower( sNew.sCpp ); + // If its temp skip this + if ( sNew.sCpp.find( AT_TEMP_CPP_LOWER_START ) == string::npos ) + { + // Get corresponding lst file for source + sNew.sLst = GetLstNameOfSource( sNew.sCpp ); + m_vSources.push_back( sNew ); + // Remove it from sSource + sSource.erase(0,iSpot+1); + // Find new one + } + iSpot = sSource.find( " " ); + } + // Pickup last or only one source + sNew.sCpp = sSource; + // Convert path from unix to win + ConvertUnixPathToWin( sNew.sCpp ); + // Lowercase it + ChangeToLower( sNew.sCpp ); + // Lst name + sNew.sLst = GetLstNameOfSource( sNew.sCpp ); + if ( sNew.sCpp.find( AT_TEMP_CPP_LOWER_START ) == string::npos ) + { + // Get corresponding lst file for source + sNew.sLst = GetLstNameOfSource( sNew.sCpp ); + m_vSources.push_back( sNew ); + } +} +bool CATModule2::CreateTempCpp(const string& sS60FileName + , int eLoggingMode + , int eBuildType + , int iAllocCallStackSize + , int iFreeCallStackSize ) +{ + LOG_FUNC_ENTRY("CATModule2::CreateTemporaryCpp"); + // S60 filename + m_sS60FileName = sS60FileName; + // Make s60 filename target.type.dat if its empty and logging mode is file + if ( eLoggingMode == CATProject::FILE + && m_sS60FileName.empty() ) + { + m_sS60FileName = m_sTarget; + m_sS60FileName.append("."); + m_sS60FileName.append( m_sTargetType ); + m_sS60FileName.append(".dat"); + } + return CreateTemporaryCpp( GetUniqueId(), m_sTempPath, + m_sS60FileName, eLoggingMode, eBuildType, iAllocCallStackSize, iFreeCallStackSize ); +} + +bool CATModule2::ModifyMmp() +{ + LOG_FUNC_ENTRY("CATModule2::ModifyMmp"); + // Create backup + if ( ! m_Mmp.BackupMmpFile() ) + return false; + // Hook + return m_Mmp.EditMmpFile( m_sTargetType, GetUniqueId() ); +} + +bool CATModule2::RestoreMmp() +{ + LOG_FUNC_ENTRY("CATModule2::RestoreMmp"); + // Restore mmp from backup + return m_Mmp.RestoreMmpFile(); +} + +bool CATModule2::VerifyAndRecoverMmp() +{ + LOG_FUNC_ENTRY("CATModule2::VerifyAndRecoverMmp"); + // Verify mmp + return m_Mmp.VerifyAndRecover(); +} + +// ---------------------------------------------------------------------------- +// Releasables Handling methos +// ---------------------------------------------------------------------------- +bool CATModule2::CopyReleasables() +{ + LOG_FUNC_ENTRY("CATModule2::CopyReleasables"); + bool bRet = true; + if ( ! CopyLstFilesToTemp() ) + bRet = false; + if ( ! CopyMapFileToTemp() ) + bRet = false; + return bRet; +} + +bool CATModule2::CopyLstFilesToDir( const string& sDir ) +{ + LOG_FUNC_ENTRY("CATModule2::CopyLstFilesToDir"); + bool bRet = true; + // Copy lst files to given directory. + vector::const_iterator source; + for( source = m_vSources.begin(); source != m_vSources.end() ; source++ ) + { + if ( ! FileCopyToPath( source->sLst, sDir ) ) + { + if ( !FileExists( source->sLst.c_str() ) ) + { + m_sErrors.append( "Missing listing file: " ); + m_sErrors.append( source->sLst ); + m_sErrors.append( "\n" ); + } + if ( !DirectoryExists( sDir.c_str() ) ) + { + m_sErrors.append( "Missing folder: " ); + m_sErrors.append( sDir ); + m_sErrors.append( "\n" ); + } + bRet = false; + } + } + // Return. + return bRet; +} + +bool CATModule2::CopyLstFilesToTemp() +{ + LOG_FUNC_ENTRY("CATModule2::CopyLstFilesToTemp"); + // Return boolean + bool bRet = true; + // Move all lst files except tmp cpp + vector::iterator it = m_vSources.begin(); + while ( it != m_vSources.end() ) + { + if ( !FileCopyToPath( it->sLst, m_sTempPath ) ) + { + if ( !FileExists( it->sLst.c_str() ) ) + { + m_sErrors.append( "Missing listing file: " ); + m_sErrors.append( it->sLst ); + m_sErrors.append( "\n" ); + } + if ( !DirectoryExists( m_sTempPath.c_str() ) ) + { + m_sErrors.append( "Missing folder: " ); + m_sErrors.append( m_sTempPath ); + m_sErrors.append( "\n" ); + } + bRet = false; + } + it++; + } + return bRet; +} + +bool CATModule2::DeleteLstFilesFromSrc( void ) +{ + LOG_FUNC_ENTRY("CATModule2::DeleteLstFilesFromSrc"); + vector::iterator it = m_vSources.begin(); + bool bRet = true; + // Delete lst files + while ( it != m_vSources.end() ) + { + if ( ! FileDelete( it->sLst, true ) ) + bRet = false; + it++; + } + return bRet; +} + +bool CATModule2::CopyMapFileToTemp() +{ + LOG_FUNC_ENTRY("CATModule2::CopyMapFileToTemp"); + // Return boolean + bool bRet = true; + // Map File to copy + string sMapFile = GetMapFile(); + if ( !FileCopyToPath( sMapFile, m_sTempPath ) ) + { + bRet = false; + if ( !FileExists( sMapFile.c_str() ) ) + { + // Add missing map file to error string. + m_sErrors.append( "Missing map file: " ); + m_sErrors.append( sMapFile ); + m_sErrors.append( "\n" ); + } + if ( !DirectoryExists( m_sTempPath.c_str() ) ) + { + // Add missing temporary folder + m_sErrors.append( "Missing folder: " ); + m_sErrors.append( m_sTempPath ); + m_sErrors.append( "\n" ); + } + } + return bRet; +} + +bool CATModule2::CleanTemporaryDir() +{ + LOG_FUNC_ENTRY("CATModule2::CleanTemporaryDir"); + bool bRet = true; + // Verify mmp + if ( ! m_Mmp.VerifyAndRecover() ) + bRet = false; + // Clean temporary dir + vector vFileList = DirList( m_sTempPath, false , true ); + vector::iterator it = vFileList.begin(); + // Size of constant table + int iCount = sizeof( TEMP_EXTENSION_NO_DELETE ) / sizeof( string ); + while ( it != vFileList.end() ) + { + // Get extension and compare it to list + bool bDelete = true; + string sExtension = GetExtension( *it ); + ChangeToLower( sExtension ); + for ( int i = 0 ; i < iCount ; i++ ) + { + if( sExtension.compare( TEMP_EXTENSION_NO_DELETE[i] ) == 0 ) + { + bDelete = false; + break; + } + } + if ( bDelete ) + { + // Delete file + if ( ! FileDelete( *it, true ) ) + bRet = false; + } + // Increment + it++; + } + return bRet; +} + +bool CATModule2::DeleteTemporaryDir() +{ + LOG_FUNC_ENTRY("CATModule2::DeleteTemporaryDir"); + bool bRet = true; + // Verify mmp + if ( ! m_Mmp.VerifyAndRecover() ) + bRet = false; + // Delete temp dir + if ( !DirDelete( m_sTempPath, true ) ) + bRet = false; + return bRet; +} + +bool CATModule2::IsUDEB() const +{ + LOG_LOW_FUNC_ENTRY("CATModule2::IsUDEB"); + // Determine from variant is this udeb + if ( m_sVariantType.find( "udeb" ) != string::npos ) + return true; + return false; +} +// ---------------------------------------------------------------------------- +// Private AddressToLine related methods +// ---------------------------------------------------------------------------- +bool CATModule2::InitializeAddressToLine() +{ + LOG_FUNC_ENTRY("CATModule2::InitializeAddressToLine"); + bool bRet = true; + // Read in different way depending on platform + if ( m_sVariantPlatform.compare("armv5") == 0 ) + { + // Add static library lst files to source vector, + // before reading them. + vector vFiles = DirList( AT_TEMP_LST_DIR, false, true ); + for(vector::iterator it = vFiles.begin() ; it != vFiles.end() ; it ++ ) + { + SOURCE source; + source.bStatic = true; + source.sLst = *it; + source.sCpp = *it; + source.sCpp = CATBase::RemovePathAndExt( source.sCpp, false ); + source.sCpp.append( ".cpp" ); + m_vSources.push_back( source ); + } + + if ( ! ReadListingFilesArmv5() ) + bRet = false; + if ( ! ReadMapFileArmv5() ) + bRet = false; + + if ( bRet ) + m_bAddressToLineInitialized = true; + } + return bRet; +} + + +bool CATModule2::ReadListingFilesArmv5() +{ + LOG_FUNC_ENTRY("CATModule2::ReadListingFilesArmv5"); + char cTemp[MAX_LINE_LENGTH]; + vector::iterator viFileIter = m_vSources.begin(); + int iNumberOfLstFiles = (int)m_vSources.size(); + vector vTempLines; + string sFileName; + + // Open all .lst files + while( iNumberOfLstFiles > 0 ) + { + // Make .lst file name + sFileName.clear(); + + // If lst file is not from static library make path to modules temporary directory. + if ( viFileIter->bStatic != true ) + { + // Remove path + if( viFileIter->sLst.find("\\") != string::npos ) + sFileName.append( + viFileIter->sLst.substr( viFileIter->sLst.find_last_of( "\\" ) + 1 + , viFileIter->sLst.size() ) ); + else + sFileName.append( viFileIter->sLst ); + + // Add temporary dir + sFileName.insert( 0, m_sTempPath ); + } + else + { + // Lst from static library don't change path. + sFileName = viFileIter->sLst; + } + // Open lst file + ifstream in( sFileName.c_str() ); + + // If file can not be opened, try to open next file + if( !in.good() ) + { + viFileIter++; + iNumberOfLstFiles--; + continue; + } + + string sTemp; + // Clear temporary lines + vTempLines.clear(); + // Add all lines to temp list + do + { + in.getline( cTemp, MAX_LINE_LENGTH ); + sTemp.clear(); + sTemp.append( cTemp ); + vTempLines.push_back( sTemp ); + } + while( in.good() ); + + LINE_IN_FILE structLineInFile; + + bool bFindENDP = false; + vector::iterator viLinesIter = vTempLines.begin(); + + // Loop throw all lines in .lst file + while( viLinesIter != vTempLines.end() ) + { + // Find ";;;" + if( !bFindENDP && strstr(viLinesIter->c_str(), ";;;") != NULL ) + { + bFindENDP = true; + + vector::iterator viLineTempIter = viLinesIter; + + // Find top line of function definition + while( viLineTempIter->size() > 0 ) + { + viLineTempIter--; + } + viLineTempIter++; + structLineInFile.sFunction.clear(); + structLineInFile.sFunction.append( viLineTempIter->c_str() ); + + viLinesIter++; + // Get Line + sTemp.clear(); + sTemp.append( viLinesIter->c_str() ); + sTemp.erase(0,3); + size_t iSize = sTemp.find_first_of(' '); + if( iSize != string::npos ) + sTemp.resize(iSize); + structLineInFile.iLine = atoi( sTemp.c_str() ); + + structLineInFile.sFileName.clear(); + structLineInFile.sFileName.append( viFileIter->sCpp.c_str() ); + structLineInFile.sLstName = sFileName; + m_vLineInFile.push_back( structLineInFile ); + } + else if( strstr(viLinesIter->c_str(), "ENDP") != NULL ) + bFindENDP = false; + viLinesIter++; + } + viFileIter++; + iNumberOfLstFiles--; + } + if( m_vLineInFile.size() > 0 ) + return true; + return false; +} + +bool CATModule2::ReadMapFileArmv5() +{ + LOG_FUNC_ENTRY("CATModule2::ReadMapFileArmv5"); + // Map file name + string sMapFileName = GetMapFile(); + // Remove path + if ( sMapFileName.find("\\") != string::npos ) + sMapFileName.erase(0, sMapFileName.find_last_of('\\')+1 ); + // Add temp path + sMapFileName.insert(0, m_sTempPath ); + + // Open .map file + ifstream in( sMapFileName.c_str() ); + + // File open ok? + if( ! in.good() ) + { + in.close(); + return false; + } + char cTemp[MAX_LINE_LENGTH]; + bool bFirstFuncFound = false; + // Get all lines where is "Thumb" + do + { + // Load one line from .map file + in.getline( cTemp, MAX_LINE_LENGTH ); + // Find _E32Startup + if( !bFirstFuncFound && ( strstr( cTemp, "_E32Startup" ) != NULL) ) + { + bFirstFuncFound = true; + } + else if( !bFirstFuncFound && ( strstr( cTemp, "_E32Dll" ) != NULL) ) + { + bFirstFuncFound = true; + } + else if( !bFirstFuncFound ) + // Skip if _E32Startup not found + continue; + + if( strstr( cTemp, "Thumb Code" ) != NULL || strstr( cTemp, "ARM Code" ) != NULL) + { + MAP_FUNC_INFO structMapFileLineInfo; + structMapFileLineInfo.sWholeLine.append( cTemp ); + + // Get memory string address from line + char* pStart = strstr( cTemp, "0x" ); + // Check did strstr return null. + if( pStart == NULL ) + continue; + char* pTemp = pStart; + char TempString[MAX_LINE_LENGTH]; + TempString[0] = 0; + size_t iLength = 0; + while( *pTemp != ' ' ) + { + TempString[iLength] = *pTemp; + pTemp++; + iLength++; + } + TempString[iLength] = 0; + + structMapFileLineInfo.iAddress = CATDatParser::_httoi( TempString ); + + pTemp = cTemp; + TempString[0] = 0; + + // Get function name + + // Skip spaces + while( *pTemp == ' ' ) + { + pTemp++; + } + iLength = 0; + // Find end of function name + string sTemp( pTemp ); + + // Location of character ')' + iLength = sTemp.find_first_of(')'); + + // Location of character ' ' + size_t iLength2 = sTemp.find_first_of(' '); + + // If ')' character is the last char and + // character ' ' is closer than ')' use location of ' ' + if( ( iLength + 1 ) == sTemp.length() && iLength2 < iLength ) + iLength = iLength2 - 1; + + if( iLength != string::npos ) + sTemp.resize( (iLength + 1) ); + + structMapFileLineInfo.sFunctionName.append( sTemp.c_str() ); + + bool bARM = false; + // Find function length + pStart = strstr( cTemp, "Thumb Code" ); + if( pStart == NULL ) + { + pStart = strstr( cTemp, "ARM Code" ); + bARM = true; + } + if( pStart != NULL ) + { + if( bARM ) + pStart += 8; + else + pStart += 10; + while(*pStart == ' ') + { + pStart++; + } + sTemp.clear(); + sTemp.append( pStart ); + size_t iSize = sTemp.find_first_of(' '); + if( iSize != string::npos ) + sTemp.resize( iSize ); + } + + structMapFileLineInfo.iFuncLength = atoi( sTemp.c_str() ); + if( bFirstFuncFound && structMapFileLineInfo.iFuncLength > 0 ) + // Save to list + m_vMapFileFuncList.push_back( structMapFileLineInfo ); + } + } + while( in.good() ); + in.close(); + return true; +} + +int CATModule2::FindLeakCodeLine( string& sFileName, int iLine, unsigned long iFromFuncAddress ) const +{ + LOG_LOW_FUNC_ENTRY("CATModule2::FindLeakCodeLine"); + if ( sFileName.empty() ) + return -1; + char cLineFromFile[MAX_LINE_LENGTH]; + vector vTempLines; + string sTemp; + char* pTemp = NULL; + char* pTempEnd = NULL; + int iFoundLine = -1; + int iRet = -1; + + // Open lst file + ifstream in( sFileName.c_str() ); + + bool bLineFound = false; + bool bFirstAddressInFuncFound = false; + unsigned long iFirstAddressInFunc = 0; + while( in.good() ) + { + in.getline( cLineFromFile, MAX_LINE_LENGTH ); + + if( bLineFound ) + { + vTempLines.push_back( cLineFromFile ); + // Is first character digit + if( isdigit( cLineFromFile[0] ) ) + { + if( !bFirstAddressInFuncFound ) + { + bFirstAddressInFuncFound = true; + sTemp.clear(); + sTemp.append( cLineFromFile ); + // Get value until next space + sTemp.resize( sTemp.find_first_of(' ') ); + + iFirstAddressInFunc = CATDatParser::_httoi( sTemp.c_str() ); + + // Return function start line if margin 0 + if( iFromFuncAddress == 0 ) + { + iRet = iLine; + return iRet; + } + } + else + { + // Find correct line using iFromFuncAddress variable + sTemp.clear(); + sTemp.append( cLineFromFile ); + // Get value until next space + sTemp.resize( sTemp.find_first_of(' ') ); + + unsigned long iValue = CATDatParser::_httoi( sTemp.c_str() ); + + if( ( iValue - iFirstAddressInFunc ) >= iFromFuncAddress ) + { + // If there is data in function, code line can not be found + if( strstr( cLineFromFile , "DCB" ) != NULL ) + { + iRet = -1; + return iRet; + } + pTemp = strstr( cLineFromFile, ";" ); + // Get line number + bool bStringNumber = true; + if( pTemp != NULL ) + { + string sTempLine( pTemp + 1 ); + // Are all characters numbers? + for( unsigned int i = 0 ; i < sTempLine .size() ; i++ ) + { + if( !isdigit(sTempLine[i]) ) + { + bStringNumber = false; + break; + } + } + } + else + bStringNumber = false; + if( bStringNumber ) + { + pTemp++; + // Get line number + iRet = atoi( pTemp ); + } + else + { + vector::iterator sTempIter = vTempLines.end(); + + sTempIter--; + + // Find last code line + while( sTempIter != vTempLines.begin() ) + { + if( strstr( sTempIter->c_str() , "DCB" ) != NULL ) + { + iRet = -1; + return iRet; + } + if( strstr( sTempIter->c_str() , ";;;" ) == NULL ) + sTempIter--; + else + break; + } + if(sTempIter == vTempLines.begin() && strstr( sTempIter->c_str() , ";;;" ) == NULL) + { + iRet = -1; + return iRet; + } + sTempIter->erase( 0, 3 ); + sTempIter->resize( sTempIter->find(' ') ); + + // Leak line + iRet = atoi( sTempIter->c_str() ); + } + return iRet; + } + } + } + } + else // Line in file not found + { + // Find line of function + if( strstr( cLineFromFile, ";;;" ) != NULL ) + { + pTemp = &cLineFromFile[0]; + // Skip characters ";;;" + pTemp += 3; + pTempEnd = pTemp; + // Find end of line number + while( *pTempEnd != ' ' ) + { + pTempEnd++; + } + *pTempEnd = 0; + iFoundLine = atoi( pTemp ); + *pTempEnd = ' '; + if( iLine == iFoundLine ) + { + bLineFound = true; + } + } + } + } + return iRet; +} + +bool CATModule2::IsMakeSuccessfull() +{ + LOG_FUNC_ENTRY("CATModule2::IsMakeSuccessfull"); + m_sErrors.clear(); + + string sSearch; + bool bMakeSuccess = true; + + // Lst files checked only with armv5 platform. + if ( IsPlatformArmv5() ) + { + sSearch.append( m_sTempPath ); + sSearch.append( "*.lst" ); + if( !SearchFileWithExtension( sSearch.c_str(), false, m_sErrors ) ) + bMakeSuccess = false; + + // Map + sSearch.clear(); + sSearch.append( m_sTempPath ); + sSearch.append( "*.map" ); + if( !SearchFileWithExtension( sSearch.c_str(), false, m_sErrors ) ) + bMakeSuccess = false; + } + + // .tmp + sSearch.clear(); + sSearch.append( m_sTempPath ); + sSearch.append( "*.tmp" ); + if( !SearchFileWithExtension( sSearch.c_str(), false, m_sErrors ) ) + bMakeSuccess = false; + + return bMakeSuccess; +} + +bool CATModule2::CreateBuildCompleteFile() +{ + LOG_FUNC_ENTRY("CATModule2::CreateBuildCompleteFile"); + // Don't create file if temp path not set cause might be anywhere + if ( m_sTempPath.empty() ) + return false; + // Create empty file indicating this module is build + string sFile = m_sTempPath; + if( sFile.at( sFile.length() - 1 ) != '\\' ) + sFile.append("\\"); + sFile.append( "BuildComplete" ); + ofstream out( sFile.c_str() ); + out << m_sVariantPlatform << endl; + out << m_sVariantType << endl; + out.close(); + return true; +} + +bool CATModule2::ReadMakeFileFromTemp() +{ + LOG_FUNC_ENTRY("CATModule2::ReadMakeFileFromTemp"); + // Set makefile to point to temporary directory. + string sMakeFile = m_sTempPath; + sMakeFile.append( RemovePathAndExt( m_Mmp.m_sMmpFile, true ) ); + sMakeFile.append( "." ); + sMakeFile.append( AT_LEVEL_2_MAKEFILE_EXT ); + m_sMakeFile = sMakeFile; + return ReadMakeFilePrivate(); +} + +bool CATModule2::ReadMakeFile() +{ + LOG_FUNC_ENTRY("CATModule2::ReadMakeFile"); + // Read makefile + if ( ReadMakeFilePrivate() ) + { + // Copy makefile to temporary directory. + string sMakeFile = m_sTempPath; + sMakeFile.append( RemovePathAndExt( m_Mmp.m_sMmpFile, true ) ); + sMakeFile.append( "." ); + sMakeFile.append( AT_LEVEL_2_MAKEFILE_EXT ); + FileCopyToPath( m_sMakeFile, sMakeFile ); + return true; + } + return false; +} + +bool CATModule2::ReadMakeFilePrivate() +{ + LOG_FUNC_ENTRY("CATModule2::ReadMakeFilePrivate"); + + if ( m_sMakeFile.empty() ) + return false; + + LOG_STRING( "using makefile :" << m_sMakeFile ); + + // Stream object to read files + ifstream in; + // Char array to read line from file + char cLine[MAX_LINE_LENGTH]; + // String to use as buffer from file + string sLine; + // Open file + in.open( m_sMakeFile.c_str(), ios_base::in ); + // Check that its open + if ( ! in.good() ) + { + // Cannot open file + cout << AT_MSG << "Error, can not open file: " << m_sMakeFile << endl; + return false; + } + // Check is it wrapper makefile (starts with "%:") + in.getline( cLine, MAX_LINE_LENGTH ); + if ( cLine[0] == '%' && cLine[1] == ':' ) + { + LOG_STRING("Found wrapper makefile"); + in.close(); + // Use ".default" makefile + string sDefaultMakeFile = m_sMakeFile.substr( 0, m_sMakeFile.find_last_of( "." ) ); + sDefaultMakeFile.append( ".DEFAULT" ); + LOG_STRING( "using makefile :" << m_sMakeFile ); + // Does default exists. If not we need to run "wrapper make" + if ( ! FileExists( sDefaultMakeFile.c_str() ) ) + { + // Run the wrapper make to create "real" makefile + string sMakeFileCmd; + sMakeFileCmd.append("make -f \""); + sMakeFileCmd.append( m_sMakeFile ); + sMakeFileCmd.append( "\"" ); + LOG_STRING( "using makefile :" << m_sMakeFile ); + cout << AT_MSG_SYSTEM_CALL << sMakeFileCmd << endl; + int iRet = (int)system( sMakeFileCmd.c_str() ); + if ( iRet ) + { + cout << MAKE_ERROR; + return false; + } + } + m_sMakeFile = sDefaultMakeFile; + // Open new file + in.open( m_sMakeFile.c_str(), ios_base::in ); + // Check that it's open + if ( ! in.good() ) + { + // Cannot open file + cout << AT_MSG << "Error, can not open makefile: " << m_sMakeFile << endl; + return false; + } + } + in.seekg( ios_base::beg ); + + // Number of lines to read at max for basic module information. + int iReadLineCount = 20; + // Extension from target line. to be compared with targettype. + string sTargetExtension; + // Read line at a time. Loop until we find it or eof + do { + // Read line from file to array + in.getline( cLine, MAX_LINE_LENGTH ); + iReadLineCount--; + + sLine.clear(); + // Put that to string + sLine.append( cLine ); + // Search target + if ( sLine.find( MAKEFILE_TARGET_STRING ) != string::npos ) + { + // Found it. Now remove other than type from line + sLine.erase( 0, strlen( MAKEFILE_TARGET_STRING ) ); + ChangeToLower( sLine ); + sTargetExtension.clear(); + sTargetExtension = GetExtension( sLine ); + m_sTarget = RemovePathAndExt( sLine, true); + LOG_STRING("found target: " << sLine ); + } + // Search targettype + else if ( sLine.find( MAKEFILE_TARGETTYPE_STRING ) != string::npos ) + { + // Found it. Now remove other than type from line + sLine.erase( 0, strlen( MAKEFILE_TARGETTYPE_STRING ) ); + ChangeToLower( sLine ); + m_sTargetType = sLine; + LOG_STRING("found target type: " << m_sTargetType ); + } + else if ( sLine.find( MAKEFILE_BASIC_TARGETTYPE_STRING ) != string::npos ) + { + sLine.erase( 0, strlen( MAKEFILE_BASIC_TARGETTYPE_STRING ) ); + ChangeToLower( sLine ); + m_sRequestedTargetExt = sLine; + // Compare with the extension in target line if not same use target lines if its "valid". + if ( m_sRequestedTargetExt.compare( sTargetExtension ) != 0 && sTargetExtension.size() > 0 ) + m_sRequestedTargetExt = sTargetExtension; + LOG_STRING("found requested target extension: " << m_sTargetType ); + } + // Feature variant details + else if ( sLine.find( MAKEFILE_FEATURE_VARIANT_NAME ) != string::npos ) + { + sLine.erase( 0, strlen( MAKEFILE_FEATURE_VARIANT_NAME ) ); + m_sFeatureVariantName = sLine; + LOG_STRING("found feature variant name: " << sLine ); + } + else if ( sLine.find( MAKEFILE_FEATURE_VARIANT_UREL_LABEL ) != string::npos ) + { + sLine.erase( 0, strlen( MAKEFILE_FEATURE_VARIANT_UREL_LABEL ) ); + LOG_STRING("found feature variant urel label: " << sLine ); + if ( sLine.compare("INVARIANT") != 0 ) + m_sFeatureVariantURELLabel = sLine; + } + else if ( sLine.find( MAKEFILE_FEATURE_VARIANT_UDEB_LABEL ) != string::npos ) + { + sLine.erase( 0, strlen( MAKEFILE_FEATURE_VARIANT_UDEB_LABEL ) ); + LOG_STRING("found feature variant udeb label: " << sLine ); + if ( sLine.compare("INVARIANT") != 0 ) + m_sFeatureVariantUDEBLabel = sLine; + } + } while( in.good() && iReadLineCount > 0 ); + + // Search compile definitions + // CWDEFS CCDEFS ARMCCDEFS + do + { + in.getline( cLine, MAX_LINE_LENGTH ); + sLine.clear(); + sLine.append( cLine ); + if ( sLine.substr( 0 , 6 ).compare( string("CWDEFS") ) == 0 + || sLine.substr( 0 , 6 ).compare( string("CCDEFS") ) == 0 ) + { + sLine.erase( 0, 8 ); + m_sCompileDefinitions = sLine; + break; + } + else if( sLine.substr( 0 , 9 ).compare( string("ARMCCDEFS") ) == 0 ) + { + sLine.erase( 0, 11 ); + m_sCompileDefinitions = sLine; + break; + } + } while( in.good() ); + // Move reading back to start if we could not find compile flags. + in.seekg( ios_base::beg ); + + // Search listing information (modules source files). + int iFindItem = 1; //1 = Source, 2 = LISTINGUDEB/UREL, 3 = lst file + string sCdefs; + string sSource; + string sLst; + do + { + in.getline( cLine, MAX_LINE_LENGTH ); + sLine.clear(); + sLine.append( cLine ); + + switch( iFindItem ) + { + case 1: + if( sLine.find( "# Source " ) != string::npos ) + { + iFindItem = 2; + // Remove text "# Source " + sLine.erase( 0, 9 ); + sSource = sLine; + } + break; + case 2: + if( IsUDEB() ) + { + if( sLine.find( "LISTINGUDEB" ) != string::npos ) + { + iFindItem = 3; + } + } + else + { + if( sLine.find( "LISTINGUREL" ) != string::npos ) + { + iFindItem = 3; + } + } + break; + case 3: + if( sLine.find( "perl -S ecopyfile.pl" ) != string::npos ) + { + // Save lst file to list + sLine.erase( 0, ( sLine.find_first_of( "\\" ) ) ); + // remove last char if '"' + if ( sLine.at( sLine.size()-1 ) == '"' ) + sLine.erase( sLine.size()-1, sLine.size() ); + sLst = sLine; + AddSource( sSource, sLst ); + iFindItem = 1; + sSource.clear(); sLst.clear(); + + } + break; + } + } + while( in.good() ); + // close and return + in.close(); + return true; +} + +// ---------------------------------------------------------------------------- +// Get & Sets +// ---------------------------------------------------------------------------- +string CATModule2::GetErrors() const +{ + LOG_LOW_FUNC_ENTRY("CATModule2::GetErrors"); + return m_sErrors; +} + +string CATModule2::GetS60FileName() const +{ + LOG_LOW_FUNC_ENTRY("CATModule2::GetS60FileName"); + if ( m_sS60FileName.empty() ) + { + string sGeneratedDatName = m_sTarget; + sGeneratedDatName.append("."); + sGeneratedDatName.append( m_sTargetType ); + sGeneratedDatName.append(".dat"); + return sGeneratedDatName; + } + return m_sS60FileName; +} + +string CATModule2::GetLstNameOfSource(string sSource) const +{ + LOG_LOW_FUNC_ENTRY("CATModule2::GetLstNameOfSource"); + // Find . before xtension + size_t iSpot = sSource.find_last_of( "." ); + // Get sub string to there + string sLst = sSource.substr(0, iSpot+1); + if ( m_sVariantPlatform.compare( "winscw" ) != 0 ) + { + // Add variant platform (i.e. armv5) + sLst.append( m_sVariantPlatform ); + sLst.append( "." ); + // Add variant type (i.e. build type liek urel) + sLst.append( m_sVariantType ); + sLst.append( "." ); + // Add target binary name + sLst.append( m_sTarget ); + sLst.append( "." ); + // Add target requested binary extension + sLst.append( m_sRequestedTargetExt ); + sLst.append( "." ); + // Add lst extension + sLst.append( "lst" ); + } + else + { + sLst.append( "WINSCW.lst" ); + } + return sLst; +} + +bool CATModule2::IsPlatformArmv5() const +{ + LOG_LOW_FUNC_ENTRY("CATModule2::IsPlatformArmv5"); + if ( _stricmp( m_sVariantPlatform.c_str(), "armv5" ) == 0 ) + return true; + return false; +} + +string CATModule2::GetMapFile() const +{ + LOG_LOW_FUNC_ENTRY("CATModule2::GetMapFile"); + // Map file with path using variables + string sMapFile( m_sReleasePath ); + if ( ! sMapFile.empty() ) + sMapFile.append( "\\" ); + sMapFile.append( m_sFullVariantPath ); + if ( ! m_sFullVariantPath.empty() ) + sMapFile.append( "\\" ); + sMapFile.append( m_sTarget ); + sMapFile.append( "." ); + // Possible feature variant. Note debug might not be defined + // when release has got one. + if ( IsUDEB() && !m_sFeatureVariantUDEBLabel.empty() ) + { + sMapFile.append( m_sFeatureVariantUDEBLabel ); + sMapFile.append( "." ); + } + + if ( !IsUDEB() && !m_sFeatureVariantURELLabel.empty() ) + { + sMapFile.append( m_sFeatureVariantURELLabel ); + sMapFile.append( "." ); + } + sMapFile.append( m_sRequestedTargetExt ); + sMapFile.append( ".map" ); + return sMapFile; +} + +string CATModule2::GetSymbolFile() const +{ + LOG_LOW_FUNC_ENTRY("CATModule2::GetSymbolFile"); + // Symbol file with path using variables + string sSymbolFile( m_sReleasePath ); + sSymbolFile.append( "\\" ); + sSymbolFile.append( m_sFullVariantPath ); + sSymbolFile.append( "\\" ); + sSymbolFile.append( m_sTarget ); + sSymbolFile.append( "." ); + // Possible feature variant. + if ( ! m_sFeatureVariantUDEBLabel.empty() || ! m_sFeatureVariantURELLabel.empty() ) + { + if ( IsUDEB() ) + sSymbolFile.append( m_sFeatureVariantUDEBLabel ); + else + sSymbolFile.append( m_sFeatureVariantURELLabel ); + sSymbolFile.append( "." ); + } + + if ( m_eBuildSystem == CATProject::SBS_V1 ) + { + sSymbolFile.append( "sym" ); + return sSymbolFile; + } + sSymbolFile.append( m_sRequestedTargetExt ); + sSymbolFile.append( ".sym" ); + return sSymbolFile; +} + +string CATModule2::GetBinaryFile() const +{ + LOG_LOW_FUNC_ENTRY("CATModule2::GetBinaryFile"); + // Binary file with path using variables + string sBinaryFile( m_sReleasePath ); + if ( ! sBinaryFile.empty() ) + sBinaryFile.append( "\\" ); + sBinaryFile.append( m_sFullVariantPath ); + if ( ! m_sFullVariantPath.empty() ) + sBinaryFile.append( "\\" ); + sBinaryFile.append( m_sTarget ); + sBinaryFile.append( "." ); + // Possible feature variant. + if ( ! m_sFeatureVariantUDEBLabel.empty() || ! m_sFeatureVariantURELLabel.empty() ) + { + if ( IsUDEB() ) + sBinaryFile.append( m_sFeatureVariantUDEBLabel ); + else + sBinaryFile.append( m_sFeatureVariantURELLabel ); + sBinaryFile.append( "." ); + } + sBinaryFile.append( m_sRequestedTargetExt ); + return sBinaryFile; +} + +bool CATModule2::SetMmpFile(const string& sMmpFile) +{ + LOG_FUNC_ENTRY("CATModule2::SetMmpFile"); + // Set mmp file + m_Mmp.m_sMmpFile = sMmpFile; + // Change to lower + ChangeToLower( m_Mmp.m_sMmpFile ); + // Convert + ConvertUnixPathToWin( m_Mmp.m_sMmpFile ); + // Set the temporary path. + m_sTempPath.clear(); + m_sTempPath = CreateTempPath( m_Mmp.m_sMmpFile ); + return true; +} + +bool CATModule2::CreateTemporaryDirectory() +{ + LOG_FUNC_ENTRY("CATModule2::CreateTemporaryDirectory"); + if ( m_sTempPath.empty() ) + { + LOG_STRING("Temporary path is not set."); + return false; + } + // Create temp dir if not exists + if ( ! DirectoryExists( m_sTempPath.c_str() ) ) + { + if ( !CreateDirectory( m_sTempPath.c_str(), NULL ) ) + { + cout << AT_MSG << "Error, can not create directory: " + << m_sTempPath << endl; + return false; + } + cout << AT_MSG << "Directory created: " << m_sTempPath << endl; + } + return true; +} + +void CATModule2::SetMakeFile( const string& sMakeFile ) +{ + LOG_FUNC_ENTRY("CATModule2::SetMakeFile"); + m_sMakeFile = sMakeFile; +} +string CATModule2::GetMakeFile() const +{ + LOG_LOW_FUNC_ENTRY("CATModule2::GetMakeFile"); + return m_sMakeFile; +} +string CATModule2::GetMmpFile() const +{ + LOG_LOW_FUNC_ENTRY("CATModule2::GetMmpFile"); + return m_Mmp.m_sMmpFile; +} +string CATModule2::GetTempPath() const +{ + LOG_LOW_FUNC_ENTRY("CATModule2::GetTempPath"); + return m_sTempPath; +} +void CATModule2::SetTarget(const string& sTarget) +{ + LOG_FUNC_ENTRY("CATModule2::SetTarget"); + m_sTarget = sTarget; + ChangeToLower( m_sTarget ); +} +string CATModule2::GetTarget() const +{ + LOG_LOW_FUNC_ENTRY("CATModule2::GetTarget"); + return m_sTarget; +} +string CATModule2::GetBinaryName() const +{ + LOG_LOW_FUNC_ENTRY("CATModule2::GetBinaryName"); + string sBinaryName; + sBinaryName.append( m_sTarget ); + sBinaryName.append( "." ); + sBinaryName.append( m_sRequestedTargetExt ); + return sBinaryName; +} + +void CATModule2::SetTargetType(const string& sTargetType) +{ + LOG_FUNC_ENTRY("CATModule2::SetTargetType"); + m_sTargetType = sTargetType; + ChangeToLower( m_sTargetType ); +} +string CATModule2::GetTargetType() const +{ + LOG_LOW_FUNC_ENTRY("CATModule2::GetTargetType"); + return m_sTargetType; +} +void CATModule2::SetRequestedTargetExt( const string& sRequestedTargetExt ) +{ + LOG_FUNC_ENTRY("CATModule2::SetRequestedTargetExt"); + m_sRequestedTargetExt = sRequestedTargetExt; + ChangeToLower( m_sRequestedTargetExt ); +} + +string CATModule2::GetRequestedTargetExt() const +{ + LOG_LOW_FUNC_ENTRY("CATmodule2::GetRequestedTargetExt"); + return m_sRequestedTargetExt; +} + +void CATModule2::SetVariantPlatform(const string& sVariantPlatform) +{ + LOG_FUNC_ENTRY("CATModule2::SetVariantPlatform"); + m_sVariantPlatform = sVariantPlatform; + ChangeToLower( m_sVariantPlatform ); +} +string CATModule2::GetVariantPlatform() const +{ + LOG_LOW_FUNC_ENTRY("CATModule2::GetVariantPlatform"); + return m_sVariantPlatform; +} +void CATModule2::SetVariantType(const string& sVariantType) +{ + LOG_FUNC_ENTRY("CATModule2::SetVariantType"); + m_sVariantType = sVariantType; + ChangeToLower( m_sVariantType ); +} +string CATModule2::GetVariantType() const +{ + LOG_LOW_FUNC_ENTRY("CATModule2::GetVariantType"); + return m_sVariantType; +} +void CATModule2::SetFeatureVariant(const string& sFeatureVariant) +{ + LOG_FUNC_ENTRY("CATModule2::SetFeatureVariant"); + m_sFeatureVariant = sFeatureVariant; + ChangeToLower( m_sFeatureVariant ); +} +string CATModule2::GetFeatureVariant() const +{ + LOG_LOW_FUNC_ENTRY("CATModule2::GetFeatureVariant"); + return m_sFeatureVariant; +} +void CATModule2::SetFeatureVariantName(const string& sFeatureVariantName) +{ + LOG_FUNC_ENTRY("CATModule2::SetFeatureVariantName"); + m_sFeatureVariantName = sFeatureVariantName; + ChangeToLower( m_sFeatureVariantName ); +} +string CATModule2::GetFeatureVariantName() const +{ + LOG_LOW_FUNC_ENTRY("CATModule2::GetFeatureVariantName"); + return m_sFeatureVariantName; +} +void CATModule2::SetReleasePath(const string& sReleasePath) +{ + LOG_FUNC_ENTRY("CATModule2::SetReleasePath"); + m_sReleasePath = sReleasePath; + ChangeToLower( m_sReleasePath ); + ConvertUnixPathToWin( m_sReleasePath ); + +} +string CATModule2::GetReleasePath() const +{ + LOG_LOW_FUNC_ENTRY("CATModule2::GetReleasePath"); + return m_sReleasePath; +} +void CATModule2::SetFullVariantPath(const string& sFullVariantPath) +{ + LOG_FUNC_ENTRY("CATModule2::SetFullVariantPath"); + m_sFullVariantPath = sFullVariantPath; + ChangeToLower( m_sFullVariantPath ); + ConvertUnixPathToWin( m_sFullVariantPath ); +} +string CATModule2::GetFullVariantPath() const +{ + LOG_LOW_FUNC_ENTRY("CATModule2::GetFullVariantPath"); + return m_sFullVariantPath; +} +string CATModule2::GetUniqueId() const +{ + LOG_LOW_FUNC_ENTRY("CATModule2::GetUniqueId"); + return FilterString( m_sTarget ); +} +void CATModule2::SetBuildSystem( int eBuildSystem ) +{ + LOG_FUNC_ENTRY("CATModule2::SetBuildSystem"); + m_eBuildSystem = eBuildSystem; +} + +int CATModule2::GetBuildSystem() const +{ + LOG_LOW_FUNC_ENTRY("CATModule2::GetBuildSystem"); + return m_eBuildSystem; +} + +void CATModule2::SetCompileDefinitions( const string& sCompileDefinitions ) +{ + LOG_LOW_FUNC_ENTRY( "CATModule2::SetCompileDefinitions" ); + m_sCompileDefinitions = sCompileDefinitions; +} + +string CATModule2::GetCompileDefinitions() const +{ + LOG_LOW_FUNC_ENTRY( "CATModule2::GetCompileDefinitions" ); + return m_sCompileDefinitions; +} + +void CATModule2::SetCompileInfoText( string sCompileInfoText ) +{ + LOG_LOW_FUNC_ENTRY( "CATModule2::SetCompileInfoText" ); + m_sCompileInfoText = sCompileInfoText; +} +string CATModule2::GetCompileInfoText() const +{ + LOG_LOW_FUNC_ENTRY( "CATModule2::GetCompileInfoText" ); + return m_sCompileInfoText; +} +//EOF diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/src/CATParseTraceFile.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/src/CATParseTraceFile.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,585 @@ +/* +* 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 CATParseTraceFile. +* +*/ + + +#include "../inc/ATCommonDefines.h" +#include "../inc/CATParseTraceFile.h" +#include "../inc/catdatasaver.h" +#include "../inc/CATDatParser.h" + +#include + +#define MAIN_ID "PCSS" +#define ALLOC_ID "ALLOC" // < V.1.6 allocation. +#define ALLOCH_ID "ALLOCH" // Header of multi message allocation. +#define ALLOCF_ID "ALLOCF" // Fragment of multi message allocation. +#define FREE_ID "FREE" +#define FREEH_ID "FREEH" // Header of multi message free. +#define FREEF_ID "FREEF" // Fragment of multi message free. +#define HANDLE_LEAK_ID "HANDLE_LEAK" + +const string ERROR_OCCURED = "ERROR_OCCURED"; // Error messages. +const string INCORRECT_ATOOL_VERSION = "INCORRECT_ATOOL_VERSION"; +/** +* Invalid characters in trace file line content. +* These will be filtered out before actuall parsing of line. +10 = LF +13 = CR +124 = | +*/ +const char cINVALID_TRACE_FILE_CHARS[] = { 10, 13, 124 }; + +// ----------------------------------------------------------------------------- +// CATParseTraceFile::CATParseTraceFile +// Constructor. +// ----------------------------------------------------------------------------- +CATParseTraceFile::CATParseTraceFile() +{ + LOG_FUNC_ENTRY("CATParseTraceFile::CATParseTraceFile"); + m_DataSaver.SetPrintFlag( false ); +} + +// ----------------------------------------------------------------------------- +// CATParseTraceFile::StartParse +// Main function to start trace parsing. +// ----------------------------------------------------------------------------- +bool CATParseTraceFile::StartParse( const char* pFileName, const char* pOutputFileName ) +{ + LOG_FUNC_ENTRY("CATParseTraceFile::StartParse"); + + // Return value, will be changed to true if process start found. + bool bRet = false; + + // Check pointers + if ( pFileName == NULL ) + return bRet; + + if( pOutputFileName == NULL ) + return bRet; + + if ( ! FileExists( pFileName ) ) + { + cout << AT_MSG << "Error, input file \"" + << pFileName + << "\" does not exist." << endl; + return bRet; + } + + // Open data file + ifstream in( pFileName ); + + // Check file opened ok + if ( !in.good() ) + return false; + + // Get stream size + size_t streamPos = in.tellg(); + in.seekg( 0, ios::end); + size_t streamEnd = in.tellg(); + in.seekg( 0, ios::beg); + + //Origianl characters (not filtered). + char cOriginalLineFromFile[MAX_LINE_LENGTH]; + + vector vProcessList; + int iProcessIDinList = -1; + + bool bFileVersionSaved = false; + // Read lines + while( streamPos < streamEnd ) + { + // Get one line. Don't use stream flags to determinate end of file + // it can be found too early because trace can contain "anything". + in.getline( cOriginalLineFromFile, MAX_LINE_LENGTH ); + + // Refresh position + streamPos = in.tellg(); + + // Check has bad bit flag raised. (i.e. device problems reading data) + if( in.bad() ) + { + cout << AT_MSG << "Integrity error reading the trace file, reading aborted." << endl; + return false; + } + //Filtered characters. + char cLineFromFile[MAX_LINE_LENGTH]; + char* pFiltered = cLineFromFile; + + //Loop thru all characters in original line. + for( size_t i = 0 ; cOriginalLineFromFile[i] != 0 ; i++ ) + { + //If character in line is not in invalid character array append it + //to filtered line. + if ( strchr( cINVALID_TRACE_FILE_CHARS, cOriginalLineFromFile[i] ) == 0 ) + *pFiltered++ = cOriginalLineFromFile[i]; + } + *pFiltered++ = 0; //Add null termination to filtered line. + + if( !bFileVersionSaved && *cLineFromFile != 0 ) + { + bFileVersionSaved = true; + m_DataSaver.AddString( AT_DATA_FILE_VERSION ); + m_DataSaver.AddLineToLast(); + } + + // Is there main ID? + if( strstr( cLineFromFile, MAIN_ID ) != NULL ) + { + string sRestOfLine( cLineFromFile ); + string sTemp; + + // Delete all characters before main ID + sRestOfLine.erase( 0, sRestOfLine.find( MAIN_ID ) ); + + // Get main ID + sTemp = GetStringUntilNextSpace( sRestOfLine ); + + // Is there more data in line? + if( sRestOfLine.empty() ) + { + continue; + } + + // Get next argument + sTemp = GetStringUntilNextSpace( sRestOfLine ); + // This might be process id or error message + if ( sTemp.compare( ERROR_OCCURED ) == 0 ) + { + // Api mismatch between s60 side and atool.exe + if ( sRestOfLine.find( INCORRECT_ATOOL_VERSION ) != string::npos ) + { + cout << "Test run failed because version conflict between device binaries\nand the atool.exe version used to build the application." << endl; + size_t pS = sRestOfLine.find_first_of('['); + size_t pE = sRestOfLine.find_first_of(']'); + size_t pSL = sRestOfLine.find_last_of('['); + size_t pEL = sRestOfLine.find_last_of(']'); + if ( pS != string::npos && pE != string::npos && pSL != string::npos && pEL != string::npos ) + { + string deviceVer = sRestOfLine.substr( pS+1, pE-pS-1 ); + string atoolVer = sRestOfLine.substr( pSL+1, pEL-pSL-1 ); + cout << "\tdevice: " << deviceVer << endl + << "\tatool.exe: " << atoolVer << endl; + } + } + else + cout << sRestOfLine << endl; + continue; + } + unsigned long iProcessID = _httoi( sTemp.c_str() ); + + iProcessIDinList = -1; + // Find process from list + for( unsigned int i = 0 ; i < vProcessList.size() ; i++ ) + { + if( vProcessList[i].iProcessID == iProcessID ) + { + iProcessIDinList = i; + break; + } + } + // Is Process ID found from list? + if( iProcessIDinList == -1 ) + { + CProcessData ProcessData; + ProcessData.bProcessOnGoing = false; + ProcessData.iProcessID = iProcessID; + vProcessList.push_back( ProcessData ); + iProcessIDinList = (int)vProcessList.size() - 1; + } + + // Remove spaces from end of line + while( sRestOfLine[sRestOfLine.size()-1] == ' ' ) + { + sRestOfLine.resize( sRestOfLine.size()-1 ); + } + + string sWholeTempLine( sRestOfLine ); + + // Get command + sTemp = GetStringUntilNextSpace( sRestOfLine ); + + // Use c style string for easy comparisong of command. + const char* pCommand = sTemp.c_str(); + + // Process start. + if( ! _stricmp( pCommand, LABEL_PROCESS_START ) ) + { + bRet = true; // Set return value true we found start. + vProcessList[iProcessIDinList].vData.push_back( sWholeTempLine ); + vProcessList[iProcessIDinList].bProcessOnGoing = true; + continue; + } + + // Check is process ongoing if not skip other tags. + if( vProcessList[iProcessIDinList].bProcessOnGoing == false ) + continue; + + // "Old style" allocation (< v.1.6) + if( ! _stricmp( pCommand, ALLOC_ID ) ) + { + // Add alloc + vProcessList[iProcessIDinList].Alloc( sRestOfLine ); + + // Subtests running? + vector::iterator viSubTestIter = vProcessList[iProcessIDinList].vSubTests.begin(); + while( viSubTestIter != vProcessList[iProcessIDinList].vSubTests.end() ) + { + if( viSubTestIter->bRunning ) + { + // Save alloc also to sub test + viSubTestIter->Alloc( sRestOfLine ); + } + viSubTestIter++; + } + } + else if ( ! _stricmp( pCommand, ALLOCH_ID ) ) + { + // Add alloc + vProcessList[iProcessIDinList].AllocH( sRestOfLine ); + + // Subtests running? + vector::iterator viSubTestIter = vProcessList[iProcessIDinList].vSubTests.begin(); + while( viSubTestIter != vProcessList[iProcessIDinList].vSubTests.end() ) + { + if( viSubTestIter->bRunning ) + { + // Save alloc also to sub test + viSubTestIter->AllocH( sRestOfLine ); + } + viSubTestIter++; + } + } + // Allocation fragment (call stack). + else if ( ! _stricmp( pCommand, ALLOCF_ID ) ) + { + // Add alloc fragment + vProcessList[iProcessIDinList].AllocF( sRestOfLine ); + + // Subtests running? + vector::iterator viSubTestIter = vProcessList[iProcessIDinList].vSubTests.begin(); + while( viSubTestIter != vProcessList[iProcessIDinList].vSubTests.end() ) + { + if( viSubTestIter->bRunning ) + { + // Save alloc fragment also to sub test + viSubTestIter->AllocF( sRestOfLine ); + } + viSubTestIter++; + } + } + // Command free + else if( ! _stricmp( pCommand, FREE_ID ) ) + { + // Send free + vProcessList[iProcessIDinList].Free( sRestOfLine ); + + // Subtests running? + vector::iterator viSubTestIter = vProcessList[iProcessIDinList].vSubTests.begin(); + while( viSubTestIter != vProcessList[iProcessIDinList].vSubTests.end() ) + { + if( viSubTestIter->bRunning ) + { + // Send free to subtest + viSubTestIter->Free( sRestOfLine ); + } + viSubTestIter++; + } + } + // Header free. + else if( ! _stricmp( pCommand, FREEH_ID ) ) + { + // Send free + vProcessList[iProcessIDinList].FreeH( sRestOfLine ); + + // Subtests running? + vector::iterator viSubTestIter = vProcessList[iProcessIDinList].vSubTests.begin(); + while( viSubTestIter != vProcessList[iProcessIDinList].vSubTests.end() ) + { + if( viSubTestIter->bRunning ) + { + // Send free to subtest + viSubTestIter->FreeH( sRestOfLine ); + } + viSubTestIter++; + } + + } + else if( ! _stricmp( pCommand, FREEF_ID ) ) + { + // Not used currently. + } + // Command process end + else if( ! _stricmp( pCommand, LABEL_PROCESS_END ) ) + { + // Set process has ended. + vProcessList[iProcessIDinList].bProcessOnGoing = false; + + // Save leaks + vector vLeaks; + vector::iterator viLeaks; + vProcessList[iProcessIDinList].GetLeakList( vLeaks ); + for ( viLeaks = vLeaks.begin(); viLeaks != vLeaks.end(); viLeaks++ ) + { + sTemp.clear(); + sTemp.append( LABEL_MEM_LEAK ); + sTemp.append( " " ); + sTemp.append( *viLeaks ); + vProcessList[iProcessIDinList].vData.push_back( sTemp ); + } + vProcessList[iProcessIDinList].ClearAllocs(); + + vector::iterator viHandleIter = vProcessList[iProcessIDinList].vHandleLeaks.begin(); + // Print handle leaks + while( viHandleIter != vProcessList[iProcessIDinList].vHandleLeaks.end() ) + { + sTemp.clear(); + sTemp.append( viHandleIter->c_str() ); + vProcessList[iProcessIDinList].vData.push_back( sTemp ); + viHandleIter++; + } + // Clear handle leaks from list + vProcessList[iProcessIDinList].vHandleLeaks.clear(); + + vector::iterator viSubTestIter = vProcessList[iProcessIDinList].vSubTests.begin(); + // Print sub test leaks + while( viSubTestIter != vProcessList[iProcessIDinList].vSubTests.end() ) + { + // Print sub test start + string sLine( LABEL_TEST_START ); sLine.append( " " ); + sLine.append( viSubTestIter->sStartTime ); sLine.append( " " ); + sLine.append( viSubTestIter->sSubTestName ); sLine.append( " " ); + sLine.append( viSubTestIter->sSubTestStartHandleCount ); + vProcessList[iProcessIDinList].vData.push_back( sLine ); + sLine.clear(); + + // DLL Loads. + for( vector::iterator it = viSubTestIter->vData.begin(); + it != viSubTestIter->vData.end(); it++ ) + { + vProcessList[iProcessIDinList].vData.push_back( (*it) ); + } + + // Subtest leaks. + vector vSubLeaks; + vector::iterator viSubLeaks; + viSubTestIter->GetLeakList( vSubLeaks ); + for ( viSubLeaks = vSubLeaks.begin(); viSubLeaks != vSubLeaks.end(); viSubLeaks++ ) + { + sLine.append( LABEL_MEM_LEAK ); + sLine.append( " " ); + sLine.append( *viSubLeaks ); + vProcessList[iProcessIDinList].vData.push_back( sLine ); + sLine.clear(); + } + viSubTestIter->ClearAllocs(); + + if( !viSubTestIter->sEndTime.empty() ) + { + // Print sub test end + sLine.append( LABEL_TEST_END ); sLine.append( " " ); + sLine.append( viSubTestIter->sEndTime ); sLine.append( " " ); + sLine.append( viSubTestIter->sSubTestName ); sLine.append( " " ); + sLine.append( viSubTestIter->sSubTestEndHandleCount ); + vProcessList[iProcessIDinList].vData.push_back( sLine ); + } + viSubTestIter++; + } + + // Clear sub tests from list + vProcessList[iProcessIDinList].vSubTests.clear(); + vProcessList[iProcessIDinList].vData.push_back( sWholeTempLine ); + } + else if( ! _stricmp( pCommand, LABEL_HANDLE_LEAK ) ) + { + // Make whole line + sTemp.append( " " ); + sTemp.append( sRestOfLine ); + vProcessList[iProcessIDinList].vHandleLeaks.push_back( sTemp ); + } + else if( ! _stricmp( pCommand, LABEL_DLL_LOAD ) ) + { + // Add module load to process data. + vProcessList[iProcessIDinList].vData.push_back( sWholeTempLine ); + // Add module load to subtest data if test running. + for( vector::iterator it = vProcessList[iProcessIDinList].vSubTests.begin(); + it != vProcessList[iProcessIDinList].vSubTests.end(); it++ ) + { + if( it->bRunning ) + it->vData.push_back( sWholeTempLine ); + } + + } + else if( ! _stricmp( pCommand, LABEL_DLL_UNLOAD ) ) + { + // Add module load to process data. + vProcessList[iProcessIDinList].vData.push_back( sWholeTempLine ); + // Add module unload to subtest data if test running. + for( vector::iterator it = vProcessList[iProcessIDinList].vSubTests.begin(); + it != vProcessList[iProcessIDinList].vSubTests.end(); it++ ) + { + if( it->bRunning ) + it->vData.push_back( sWholeTempLine ); + } + } + else if( sTemp.find( LABEL_LOGGING_CANCELLED ) != string::npos || + sTemp.find( LABEL_PROCESS_END ) != string::npos || sTemp.find( LABEL_ERROR_OCCURED ) != string::npos || + sTemp.find( LABEL_HANDLE_LEAK ) != string::npos ) + { + vProcessList[iProcessIDinList].vData.push_back( sWholeTempLine ); + } + else if( ! _stricmp( pCommand, LABEL_TEST_START ) ) + { + bRet = true; // Set return value true we found start. + // Get sub test time + string sSubTestTime = GetStringUntilNextSpace( sRestOfLine ); + // Get sub test name + string sSubTestName = GetStringUntilNextSpace( sRestOfLine ); + // Get sub test start handle count + string sSubTestStartHandleCount = GetStringUntilNextSpace( sRestOfLine ); + + CSubTestData SubTestData; + SubTestData.bRunning = true; + SubTestData.sStartTime = sSubTestTime; + SubTestData.sSubTestName = sSubTestName; + SubTestData.sSubTestStartHandleCount = sSubTestStartHandleCount.c_str(); + + vProcessList[iProcessIDinList].vSubTests.push_back( SubTestData ); + } + else if( ! _stricmp( pCommand, LABEL_TEST_END ) ) + { + // Get sub test time + string sSubTestEnd = GetStringUntilNextSpace( sRestOfLine ); + // Get sub test name + string sSubTestName = GetStringUntilNextSpace( sRestOfLine ); + // Get sub test end handle count + string sSubTestEndHandleCount = GetStringUntilNextSpace( sRestOfLine ); + + // Find subtest + vector::iterator viSubTestIter = vProcessList[iProcessIDinList].vSubTests.begin(); + while( viSubTestIter != vProcessList[iProcessIDinList].vSubTests.end() ) + { + if( viSubTestIter->sSubTestName == sSubTestName && viSubTestIter->sEndTime.empty() ) + { + viSubTestIter->sEndTime = sSubTestEnd; + viSubTestIter->bRunning = false; + viSubTestIter->sSubTestEndHandleCount = sSubTestEndHandleCount.c_str(); + } + viSubTestIter++; + } + } + } + } + + // Print all saved data from processes + for( unsigned int i = 0 ; i < vProcessList.size() ; i++ ) + { + // Print saved lines + for( unsigned int iDataCounter = 0 ; iDataCounter < vProcessList[i].vData.size() ; iDataCounter++ ) + { + m_DataSaver.AddString( vProcessList[i].vData[iDataCounter].c_str() ); + m_DataSaver.AddLineToLast(); + } + + string sTemp; + + // Save leaks + vector vLeaks; + vector::iterator viLeaks; + vProcessList[i].GetLeakList( vLeaks ); + for ( viLeaks = vLeaks.begin(); viLeaks != vLeaks.end(); viLeaks++ ) + { + sTemp.clear(); + sTemp.append( LABEL_MEM_LEAK ); + sTemp.append( " " ); + sTemp.append( *viLeaks ); + m_DataSaver.AddString( sTemp.c_str() ); + m_DataSaver.AddLineToLast(); + } + + vector::iterator viHandleIter = vProcessList[i].vHandleLeaks.begin(); + // Print handle leaks, if there is data left, there was no process end. + while( viHandleIter != vProcessList[i].vHandleLeaks.end() ) + { + sTemp.clear(); + sTemp.append( viHandleIter->c_str() ); + m_DataSaver.AddString( sTemp.c_str() ); + m_DataSaver.AddLineToLast(); + viHandleIter++; + } + vector::iterator viSubTestIter = vProcessList[i].vSubTests.begin(); + // Print sub test data, if there is data left, there was no process end. + while( viSubTestIter != vProcessList[i].vSubTests.end() ) + { + // Print sub test start + string sLine( LABEL_TEST_START ); sLine.append( " " ); + sLine.append( viSubTestIter->sStartTime ); sLine.append( " " ); + sLine.append( viSubTestIter->sSubTestName ); sLine.append( " " ); + sLine.append( viSubTestIter->sSubTestStartHandleCount ); + m_DataSaver.AddString( sLine.c_str() ); + m_DataSaver.AddLineToLast(); + sLine.clear(); + + // DLL Loads. + for( vector::iterator it = viSubTestIter->vData.begin(); + it != viSubTestIter->vData.end(); it++ ) + { + m_DataSaver.AddString( (*it).c_str() ); + m_DataSaver.AddLineToLast(); + } + + // Subtest leaks. + vector vSubLeaks; + vector::iterator viSubLeaks; + viSubTestIter->GetLeakList( vSubLeaks ); + for ( viSubLeaks = vSubLeaks.begin(); viSubLeaks != vSubLeaks.end(); viSubLeaks++ ) + { + sLine.append( LABEL_MEM_LEAK ); + sLine.append( " " ); + sLine.append( *viSubLeaks ); + m_DataSaver.AddString( sLine.c_str() ); + m_DataSaver.AddLineToLast(); + sLine.clear(); + } + + // Print sub test end + sLine.append( LABEL_TEST_END ); sLine.append( " " ); + sLine.append( viSubTestIter->sEndTime ); sLine.append( " " ); + sLine.append( viSubTestIter->sSubTestName ); sLine.append( " " ); + sLine.append( viSubTestIter->sSubTestEndHandleCount ); + m_DataSaver.AddString( sLine.c_str() ); + m_DataSaver.AddLineToLast(); + + viSubTestIter++; + } + } + // Save lines to file. + m_DataSaver.SaveLinesToFile( pOutputFileName, TEXT_DATA ); + // Close file. + in.close(); + return bRet; +} + +// ----------------------------------------------------------------------------- +// CATParseTraceFile::GetDataSaver +// Gets data saver object. +// ----------------------------------------------------------------------------- +CATDataSaver* CATParseTraceFile::GetDataSaver(void) +{ + LOG_LOW_FUNC_ENTRY("CATParseTraceFile::GetDataSaver"); + return &m_DataSaver; +} +//EOF diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/src/CATParseXML.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/src/CATParseXML.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,148 @@ +/* +* 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 CATParseXML. +* +*/ + + +#include "../inc/CATParseXML.h" +#include "../inc/catdatasaver.h" +#include "../inc/CATBase.h" + +#include + +const char cCanNotFindEpocroot[] = "Can not find EPOCROOT from devices.xml.\n"; +const char cErrorInDeviceXml[] = "Error in devices.xml!\n"; +const char cCanNotFind[] = "Can not find file: %s.\n"; + +CATParseXML::CATParseXML(void) +{ + LOG_FUNC_ENTRY("CATParseXML::CATParseXML"); + try + { + xercesc::XMLPlatformUtils::Initialize(); + } + catch ( ... ) + { + //Print error + printf("XML initialization failed.\n"); + } +} + +CATParseXML::~CATParseXML(void) +{ + LOG_FUNC_ENTRY("CATParseXML::~CATParseXML"); +} + +// ----------------------------------------------------------------------------- +// CATParseXML::GetEpocRootPathFromXML +// Find epocroot path in xml file +// ----------------------------------------------------------------------------- +string CATParseXML::GetEpocRootPathFromXML(const char* pSourcePath) +{ + LOG_FUNC_ENTRY("CATParseXML::GetEpocRootPathFromXML"); + string sEpocRootPath; + // Check that source exists + if ( ! CATBase::FileExists( pSourcePath ) ) + { + LOG_STRING( "Source xml not found." ); + return sEpocRootPath; + } + try + { + xercesc::XercesDOMParser* parser = new xercesc::XercesDOMParser(); + xercesc::DOMDocument* pDomDoc; + + // Get devices.xml document + parser->parse( pSourcePath ); + pDomDoc = parser->getDocument(); + + // Get root element + xercesc::DOMElement* pRootElem = pDomDoc->getDocumentElement(); + + if( pRootElem ) + { + // Get all "device" elements + LPWSTR wTemp = CATDataSaver::CharToWChar( "device" ); + xercesc::DOMNodeList* pDeviceNodeList = pRootElem->getElementsByTagName( wTemp ); + if( wTemp ) + delete[] wTemp; + + // Find default SDK + + bool bEpocRootFound = false; + int iLength = pDeviceNodeList->getLength(); + for( int i = 0 ; i < iLength ; i++ ) + { + xercesc::DOMNode* pDeviceNode = pDeviceNodeList->item(i); + + xercesc::DOMNamedNodeMap* pAttributeList = pDeviceNode->getAttributes(); + + // Find attribute "default" + + int iAttribListLength = pAttributeList->getLength(); + for( int x = 0 ; x < iAttribListLength ; x++ ) + { + xercesc::DOMNode* pAttribNode = pAttributeList->item(x); + const LPWSTR pNodeName = (const LPWSTR)pAttribNode->getNodeName(); + + if( wcscmp( pNodeName, L"default" ) == 0 ) + { + const LPWSTR pNodeValue = (const LPWSTR)pAttribNode->getNodeValue(); + + // Find node value 'yes' + if( wcscmp( pNodeValue, L"yes" ) == 0 ) + { + // Find node + xercesc::DOMNode* pChildNode = pDeviceNode->getFirstChild(); + if( !pChildNode ) + break; + while( !bEpocRootFound ) + { + if( wcscmp( pChildNode->getNodeName() , L"epocroot" ) == 0 ) + { + bEpocRootFound = true; + + // Node value is child text node + xercesc::DOMNode* pTempTextNode = pChildNode->getFirstChild(); + const LPWSTR pPathNodeValue = (const LPWSTR)pTempTextNode->getNodeValue(); + + CATDataSaver::WCharToChar( sEpocRootPath, pPathNodeValue ); + + break; + } + pChildNode = pChildNode->getNextSibling(); + if( !pChildNode ) + break; + } + } // If node value yes + } // If node name default + if( bEpocRootFound ) + break; + } // for x + if( bEpocRootFound ) + break; + } // for i + } + if(parser) + delete parser; //lint !e118 + xercesc::XMLPlatformUtils::Terminate(); + } + catch (...) + { + printf("XML parsing failed."); + } + return sEpocRootPath; +} +// End of file diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/src/CATProject.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/src/CATProject.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,2413 @@ +/* +* 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: Class representing a project. +* +*/ + + +#include "../inc/CATProject.h" +#include "../inc/CATModule2.h" +#include "../inc/CATParseTraceFile.h" +#include "../inc/CATDatParser.h" + +//dbghelp.dll version function. +extern int showDbgHelpVersionInfo( bool showVersion ); + +// ---------------------------------------------------------------------------- +// CATProject::CATProject() +// ---------------------------------------------------------------------------- +CATProject::CATProject() +{ + LOG_FUNC_ENTRY("CATProject::CATProject"); + + m_bUninstrumented = true; + m_bAbldTest = false; + + // Use windows api to acquire current directory info. + GetCurrentDirectory( MAX_LINE_LENGTH, m_cCurrentDir ); + + m_eBuildSystem = SBS_V1; + m_eBuildType = UDEB; + m_eLoggingMode = TRACE; + m_eMode = NOT_DEFINED; + + m_iLoggingLevel = 3; + + m_pAnalyzer = 0; + + m_sBinaryTarget = ""; + m_sBuildCommand = ""; + m_sDataFile = ""; + m_sDataFileOutput = ""; + m_sDataFileTemp = ""; + m_sEpocRoot = "\\"; + m_sMakeFile = ""; + m_sPlatform = ""; + m_sS60FileName = ""; + m_sTargetModule = ""; + m_sVariant = ""; + + m_vRomSymbolFiles.clear(); + m_vModules.clear(); + m_vStaticLibraries.clear(); + m_vTargetModules.clear(); + m_vUnsupportedModules.clear(); +} + +// ---------------------------------------------------------------------------- +// CATProject::~CATProject() +// ---------------------------------------------------------------------------- +CATProject::~CATProject() +{ + LOG_FUNC_ENTRY("CATProject::~CATProject"); + + CleanModuleVectors(); + + // Delete analyzer + if ( m_pAnalyzer ) + delete m_pAnalyzer; + + // Temporary datafile + if ( !m_sDataFileTemp.empty() ) + { + if ( FileExists( m_sDataFileTemp.c_str() ) ) + FileDelete( m_sDataFileTemp, false ); + } +} + +bool CATProject::SetArguments( ARGUMENTS& arguments ) +{ + LOG_FUNC_ENTRY("CATProject::SetArguments"); + bool bRet = true; + + //Project mode. + if( arguments.eHookSwitch == HOOK_INTERNAL ) + { + SetMode( CATProject::COMPILE ); + SetLoggingMode( CATProject::FILE ); + } + else if ( arguments.eHookSwitch == HOOK_EXTERNAL ) + { + SetMode( CATProject::COMPILE ); + SetLoggingMode( CATProject::TRACE ); + } + else if ( arguments.eHookSwitch == HOOK_EXTERNAL_FAST ) + { + SetMode( CATProject::COMPILE ); + SetLoggingMode( CATProject::TRACE_FAST ); + } + /* Extension*/ + else if ( arguments.eHookSwitch == HOOK_EXTENSION_INTERNAL ) + { + SetMode( CATProject::INSTRUMENT ); + SetLoggingMode( CATProject::FILE ); + } + else if ( arguments.eHookSwitch == HOOK_EXTENSION_EXTERNAL ) + { + SetMode( CATProject::INSTRUMENT ); + SetLoggingMode( CATProject::TRACE ); + } + else if ( arguments.eHookSwitch == HOOK_EXTENSION_EXTERNAL_FAST ) + { + SetMode( CATProject::INSTRUMENT ); + SetLoggingMode( CATProject::TRACE_FAST ); + } + else if ( arguments.eHookSwitch == HOOK_EXTENSION_UNINSTRUMENT ) + { + SetMode( CATProject::UNINSTRUMENT ); + } + else if ( arguments.eHookSwitch == HOOK_EXTENSION_FAILED ) + { + SetMode( CATProject::UNINSTRUMENT_FAILED ); + } + //Return if uninstrumenting because no other arguments are set. + if ( GetMode() == CATProject::UNINSTRUMENT + || GetMode() == CATProject::UNINSTRUMENT_FAILED ) + { + return bRet; + } + + // No build / instrument. + if ( arguments.HOOK.bNoBuild ) + SetMode( CATProject::INSTRUMENT_CONSOLE ); + + // Call stack sizes + SetAllocCallStackSize( arguments.HOOK.iAllocCallStackSize ); + SetFreeCallStackSize( arguments.HOOK.iFreeCallStackSize ); + + //Build system. + if ( arguments.HOOK.iBuildSystem == 1 ) + SetBuildSystem( CATProject::SBS_V1 ); + else if ( arguments.HOOK.iBuildSystem == 2 ) + SetBuildSystem( CATProject::SBS_V2 ); + + //Test module build only + if ( arguments.HOOK.bAbldTest == true ) + m_bAbldTest = true; + + //Platform. + if ( !_stricmp( arguments.HOOK.sPlatform.c_str(), "armv5" ) ) + SetPlatform( arguments.HOOK.sPlatform ); + else if ( !_stricmp( arguments.HOOK.sPlatform.c_str(), "gcce" ) ) + SetPlatform( arguments.HOOK.sPlatform ); + else if ( !_stricmp( arguments.HOOK.sPlatform.c_str(), "winscw" ) ) + SetPlatform( arguments.HOOK.sPlatform ); + else + { + LOG_STRING( "Error, no supported platform specified (armv5/gcce/winscw)."); + bRet = false; + } + + //BuildType. + if ( !_stricmp( arguments.HOOK.sBuildType.c_str(), "urel" ) ) + SetBuildType( CATProject::UREL ); + else if ( !_stricmp( arguments.HOOK.sBuildType.c_str(), "udeb" ) ) + SetBuildType( CATProject::UDEB ); + else + { + LOG_STRING( "Error, no build type specified."); + bRet = false; + } + + //Internal data file. + if ( arguments.HOOK.bDataFileName ) + SetS60FileName( arguments.HOOK.sDataFileName ); + + //Build command. + if ( arguments.HOOK.sBuildCmd.empty() && ( + GetMode() == CATProject::COMPILE || + GetMode() == CATProject::INSTRUMENT || + GetMode() == CATProject::INSTRUMENT_CONSOLE + )) + { + cout << AT_MSG << "Error, no build command specified." << endl; + bRet = false; + } + + SetBuildCommand( arguments.HOOK.sBuildCmd ); + + //Variant. + SetVariant( arguments.HOOK.sFeatureVariant ); + + //Target programs. + SetTargetModules( arguments.HOOK.vTargetPrograms ); + + return bRet; +} + +void CATProject::CleanModuleVectors() +{ + LOG_FUNC_ENTRY("CATProject::CleanModuleVectors"); + // delete modules from vector. + for( size_t i = 0; i < m_vModules.size() ; i++ ) + delete m_vModules[i]; + m_vModules.clear(); + + // Delete modules from vector (unsupported). + for( size_t i = 0; i < m_vUnsupportedModules.size() ; i++ ) + delete m_vUnsupportedModules[i]; + m_vUnsupportedModules.clear(); + + // Delete modules from static library vector. + for( size_t i = 0; i < m_vStaticLibraries.size() ; i++ ) + delete m_vStaticLibraries[i]; + m_vStaticLibraries.clear(); +} +// ---------------------------------------------------------------------------- +// CATProject::Run +// ---------------------------------------------------------------------------- +int CATProject::Run() +{ + LOG_FUNC_ENTRY("CATProject::Run"); + int iReturnCode = 0; + switch( m_eMode ) + { + case COMPILE: + // Run compile + iReturnCode = RunCompile(); + if ( iReturnCode == AT_RETURN_CODE::READ_MAKEFILE_ERROR + || iReturnCode == AT_RETURN_CODE::KERNEL_SIDE_MODULE_ERROR + || iReturnCode == AT_RETURN_CODE::INVALID_MMP_DEFINED ) + { + DeleteTemporaryDirs(); + DirDelete( AT_TEMP_DIR, true ); + } + else + { + DisplayCompileSummary(); + DisplayBuildSummary(); + } + break; + case CLEAN: + iReturnCode = RunClean(); + break; + case ANALYZE: + iReturnCode = RunAnalyze(); + break; + case INSTRUMENT: + iReturnCode = RunInstrument(); + break; + case INSTRUMENT_CONSOLE: + iReturnCode = RunInstrumentConsole(); + if ( iReturnCode == AT_RETURN_CODE::READ_MAKEFILE_ERROR + || iReturnCode == AT_RETURN_CODE::KERNEL_SIDE_MODULE_ERROR ) + { + DeleteTemporaryDirs(); + DirDelete( AT_TEMP_DIR, true ); + } + else + { + DisplayBuildSummary(); + } + break; + case UNINSTRUMENT: + iReturnCode = RunUninstrument(); + // Show summary + DisplayCompileSummary(); + DisplayBuildSummary(); + break; + case UNINSTRUMENT_CONSOLE: + iReturnCode = RunUninstrumentConsole(); + // Show summary + DisplayCompileSummary(); + DisplayBuildSummary(); + break; + case UNINSTRUMENT_FAILED: + iReturnCode = RunUninstrumentFailed(); + // Display message + cout << AT_MSG << "Build aborted, because project contains compile error(s)." + << endl; + break; + default: + cout << AT_MSG << "Error, mode not supported / implemented." << endl; + break; + } + // Error messages + switch( iReturnCode ) + { + case AT_RETURN_CODE::MAKEFILE_ERROR: + cout << AT_MSG << "Error, creating/reading makefiles." << endl; + break; + case AT_RETURN_CODE::COMPILE_ERROR: + cout << AT_MSG << "Error, compiling project." << endl; + break; + case AT_RETURN_CODE::UNKNOWN: + cout << AT_MSG << "Error, unknown." << endl; + break; + case AT_RETURN_CODE::WRONG_DATA_FILE_VERSION: + cout << AT_MSG << "unable to analyze the data file.\n"; + cout << AT_MSG << "wrong data file version.\n"; + break; + case AT_RETURN_CODE::INVALID_DATA_FILE: + cout << AT_MSG << "Error, invalid datafile." << endl; + break; + case AT_RETURN_CODE::RELEASABLES_ERROR: + cout << AT_MSG << "Error, copying releasable(s)." << endl; + break; + case AT_RETURN_CODE::RESTORE_MODULES_ERROR: + cout << AT_MSG << "Error, restoring mmp file(s)." << endl; + break; + case AT_RETURN_CODE::CREATING_TEMP_CPP_ERROR: + cout << AT_MSG << "Error, creating temporary cpp file(s)." << endl; + break; + case AT_RETURN_CODE::CLEANING_TEMP_ERROR: + cout << AT_MSG << "Error, cleaning temporary dir(s)." << endl; + break; + case AT_RETURN_CODE::READ_MAKEFILE_ERROR: + cout << AT_MSG << "Error, reading makefile." << endl; + break; + case AT_RETURN_CODE::MODIFY_MODULES_ERROR: + cout << AT_MSG << "Error, modifying mmp file(s)." << endl; + break; + case AT_RETURN_CODE::INVALID_MMP_DEFINED: + break; + case AT_RETURN_CODE::WRITE_ATTRIBUTES_ERROR: + cout << AT_MSG << "Error, writing attributes." << endl; + break; + case AT_RETURN_CODE::READ_ATTRIBUTES_ERROR: + cout << AT_MSG << "Error, reading project configuration. Instrument project again." << endl; + break; + case AT_RETURN_CODE::EMPTY_DATA_FILE: + cout << AT_MSG << "Error, no data to be analyzed." << endl; + break; + case AT_RETURN_CODE::NO_SUPPORTED_MODULES_ERROR: + cout << AT_MSG << "Error, no modules found with supported target type." << endl; + break; + case AT_RETURN_CODE::KERNEL_SIDE_MODULE_ERROR: + cout << AT_MSG << "Error, kernel side component found component. Build/instrument aborted." << endl; + break; + } + return iReturnCode; +} +// ---------------------------------------------------------------------------- +// CATProject::RunRecoveryAndExit() +// Restore modules quick and exit. Used when user wants to kill/end process. +// ---------------------------------------------------------------------------- +int CATProject::RunRecoveryAndExit() +{ + LOG_FUNC_ENTRY("CATProject::RunRecoveryAndExit"); + cout << AT_MSG << "Error, user requested exit." << endl; + VerifyAndRecoverModules(); + DeleteTemporaryDirs(); + DirDelete( AT_TEMP_DIR, true ); + cout << AT_MSG << "Exit." << endl; + return AT_RETURN_CODE::USER_ISSUED_EXIT; +} + +// ---------------------------------------------------------------------------- +// CATProject::IsUninstrumented() +// Reads projects configuration file if it exists. +// Return false in case the data contains information that project is +// uninstrumented. Otherwise returns always true. +// ---------------------------------------------------------------------------- +bool CATProject::IsUninstrumented() +{ + LOG_FUNC_ENTRY("CATProject::IsUninstrumented"); + string sCfgFile( AT_TEMP_DIR ); + sCfgFile.append( "\\" ); + sCfgFile.append( AT_PROJECT_ATTRIBUTES_FILE_NAME ); + if ( ! FileExists( sCfgFile.c_str() ) ) + return true; + if( !ReadAttributes() ) + { + LOG_STRING( "Error, reading project.cfg file." ); + return false; + } + return m_bUninstrumented; +} + +// ---------------------------------------------------------------------------- +// CATProject::RunCompile() +// Helper functions to run different modes. +// ---------------------------------------------------------------------------- +int CATProject::RunCompile() +{ + LOG_FUNC_ENTRY("CATProject::RunCompile"); + // Store attributes + if( ! MakeTempDirIfNotExist() ) + return AT_RETURN_CODE::WRITE_ATTRIBUTES_ERROR; + if ( ! WriteAttributes() ) + return AT_RETURN_CODE::WRITE_ATTRIBUTES_ERROR; + // Create makefile + if ( ! CreateMakeFile() ) + return AT_RETURN_CODE::MAKEFILE_ERROR; + // Read makefile to get project attributes + if ( ! ReadMakeFile() ) + return AT_RETURN_CODE::READ_MAKEFILE_ERROR; + // Filter unsupported + FilterModules(); + // Check that we have some "valid" modules to hook + if ( m_vModules.size() == 0 &&( m_vUnsupportedModules.size() > 0 || m_vStaticLibraries.size() > 0 ) ) + return AT_RETURN_CODE::NO_SUPPORTED_MODULES_ERROR; + // Check is possible target module defined in project + if ( ! IsTargetModuleInProject() ) + return AT_RETURN_CODE::INVALID_MMP_DEFINED; + // Clean temporary dirs of modules + if ( ! CleanTemporaryDirs() ) + return AT_RETURN_CODE::CLEANING_TEMP_ERROR; + // Create temporary cpps for modulse + if (! CreateTemporaryCpps() ) + return AT_RETURN_CODE::CREATING_TEMP_CPP_ERROR; + // Hook modules + if (! ModifyModules() ) + return AT_RETURN_CODE::MODIFY_MODULES_ERROR; + // Compile all + // Return code + int iRetCode = AT_RETURN_CODE::OK; + // Compile + if ( ! Compile() ) + iRetCode = AT_RETURN_CODE::COMPILE_ERROR; + // Listings + if (! CreateListings() ) + iRetCode = AT_RETURN_CODE::COMPILE_ERROR; + // Releasables + if (! CopyReleasables() ) + iRetCode = AT_RETURN_CODE::RELEASABLES_ERROR; + // Restore "unhook" modules + if (! RestoreModules() ) + iRetCode = AT_RETURN_CODE::RESTORE_MODULES_ERROR; + // Return error code OK + return iRetCode; +} + +int CATProject::RunClean() +{ + LOG_FUNC_ENTRY("CATProject::RunClean"); + int iRetCode = AT_RETURN_CODE::OK; + bool bNothingFound = true; + // Read attributes. + if ( ReadAttributes() ) + { + bNothingFound = false; + if ( m_eBuildSystem == SBS_V1 ) + InitSbs1MakeFileWithPathToTemp(); + // Read makefile to get project attributes + if( ReadMakeFile() ) + { + // Filter unsupported + FilterModules(); + // Restore modules to make sure no changes left + if( VerifyAndRecoverModules() ) + { + // Run reallyclean + switch ( m_eBuildSystem ) + { + case SBS_V1: + RunReallyCleanSbs1(); + break; + case SBS_V2: + RunReallyCleanSbs2(); + break; + default: + break; + } + // Delete temporary dirs of modules + if(! DeleteTemporaryDirs() ) + { + + } + } + else + { + + } + } + } + // Projects + if ( ! DirDelete( AT_TEMP_DIR, true ) ) + { + + } + else + bNothingFound = false; + + if ( bNothingFound ) + cout << AT_MSG << "Nothing found to clean." << endl; + else + cout << AT_MSG << "Cleaning done." << endl; + return iRetCode; +} + +int CATProject::RunAnalyze() +{ + LOG_FUNC_ENTRY("CATProject::RunAnalyze"); + + // Parse data file if it is trace. + if ( !IsDataFile( m_sDataFile ) ) + { + m_sDataFileTemp.clear(); + m_sDataFileTemp.append( m_sDataFile ); + m_sDataFileTemp.append( ".atool" ); + cout << AT_MSG << "Parsing trace file..." << endl; + CATParseTraceFile Parser; + if ( ! Parser.StartParse( m_sDataFile.c_str(), m_sDataFileTemp.c_str() ) ) + { + return AT_RETURN_CODE::EMPTY_DATA_FILE; + } + m_sDataFile = m_sDataFileTemp; + } + + // Init makefile member for this run mode. + if ( m_eBuildSystem == SBS_V1 ) + InitSbs1MakeFileWithPathToTemp(); + // Read makefile to get project attributes + if( ! ReadMakeFile() ) + { + cout << AT_MSG << "Error, cannot find project build with AnalyzeTool." << endl; + } + else + FilterModules(); + + #ifndef ADDR2LINE + // Initialize modules locating code lines. + for( size_t i = 0 ; i < m_vModules.size() ; i++ ) + { + m_vModules.at(i)->InitializeAddressToLine(); + } + #endif + + // Create analyzer + m_pAnalyzer = new CATDatParser( &m_vModules ); + + // Pass some info from project if it "exists" to analyzer. + if ( m_vModules.size() > 0 ) + { + // Pass platform. + m_pAnalyzer->SetProjectPlatform( m_sPlatform ); + // Pass build type. + m_pAnalyzer->SetProjectBuildType( m_eBuildType ); + } + + // Set file. + m_pAnalyzer->SetInputFile( m_sDataFile ); + + // Set rom symbol file. + m_pAnalyzer->SetRomSymbolFiles( m_vRomSymbolFiles ); + + // Set output file if specified + if ( ! m_sDataFileOutput.empty() ) + { + m_pAnalyzer->SetOutputFile( m_sDataFileOutput ); + } + // Set log level + m_pAnalyzer->SetLogLevel( m_iLoggingLevel ); + + // Analyze + return m_pAnalyzer->Analyze(); +} + +int CATProject::RunInstrument() +{ + LOG_FUNC_ENTRY("CATProject::RunInstrument"); + // Store attributes + if( ! MakeTempDirIfNotExist() ) + return AT_RETURN_CODE::WRITE_ATTRIBUTES_ERROR; + if ( ! WriteAttributes() ) + return AT_RETURN_CODE::WRITE_ATTRIBUTES_ERROR; + if ( m_eBuildSystem == SBS_V1 ) + { + // Initialize level 1 make file member. + if ( ! InitSbs1MakeFileWithPath() ) + return AT_RETURN_CODE::MAKEFILE_ERROR; + // Copy it to temporary folder. + CopyMakeFileSbs1ToTemporaryFolder(); + // Run export. + if( ! RunExportSbs1() ) + return AT_RETURN_CODE::MAKEFILE_ERROR; + // Create level 2 makefiles. + if ( ! CreateMakeFileSbs1Level2() ) + return AT_RETURN_CODE::MAKEFILE_ERROR; + } + else if ( m_eBuildSystem == SBS_V2 ) + { + // Create makefile only when using SBS v.2 + if ( ! CreateMakeFile() ) + return AT_RETURN_CODE::MAKEFILE_ERROR; + } + else + { + return AT_RETURN_CODE::UNKNOWN; + } + // Read makefile to get project attributes + if ( ! ReadMakeFile() ) + return AT_RETURN_CODE::READ_MAKEFILE_ERROR; + // Filter unsupported + FilterModules(); + // Check that we have some "valid" modules to hook + if ( m_vModules.size() == 0 &&( m_vUnsupportedModules.size() > 0 || m_vStaticLibraries.size() > 0 ) ) + return AT_RETURN_CODE::NO_SUPPORTED_MODULES_ERROR; + + // Clean temporary dirs of modules + if ( ! CleanTemporaryDirs() ) + return AT_RETURN_CODE::CLEANING_TEMP_ERROR; + // Create temporary cpps for modulse + if (! CreateTemporaryCpps() ) + return AT_RETURN_CODE::CREATING_TEMP_CPP_ERROR; + // Hook modules + if (! ModifyModules() ) + return AT_RETURN_CODE::MODIFY_MODULES_ERROR; + return AT_RETURN_CODE::OK; +} + +int CATProject::RunInstrumentConsole() +{ + LOG_FUNC_ENTRY("CATProject::RunInstrumentConsole"); + if( ! MakeTempDirIfNotExist() ) + return AT_RETURN_CODE::UNKNOWN; + // Store attributes + m_bUninstrumented = false; + if ( ! WriteAttributes() ) + return AT_RETURN_CODE::WRITE_ATTRIBUTES_ERROR; + // Create makefile + if ( ! CreateMakeFile() ) + return AT_RETURN_CODE::MAKEFILE_ERROR; + // Read makefile to get project attributes + if ( ! ReadMakeFile() ) + return AT_RETURN_CODE::READ_MAKEFILE_ERROR; + // Filter unsupported + FilterModules(); + // Check that we have some "valid" modules to hook + if ( m_vModules.size() == 0 &&( m_vUnsupportedModules.size() > 0 || m_vStaticLibraries.size() > 0 ) ) + return AT_RETURN_CODE::NO_SUPPORTED_MODULES_ERROR; + + // Clean temporary dirs of modules + if ( ! CleanTemporaryDirs() ) + return AT_RETURN_CODE::CLEANING_TEMP_ERROR; + // Create temporary cpps for modulse + if (! CreateTemporaryCpps() ) + return AT_RETURN_CODE::CREATING_TEMP_CPP_ERROR; + // Hook modules + if (! ModifyModules() ) + return AT_RETURN_CODE::MODIFY_MODULES_ERROR; + // Run Reallyclean when using abld. + if ( m_eBuildSystem == SBS_V1 ) + RunReallyCleanSbs1(); + return AT_RETURN_CODE::OK; +} + +int CATProject::RunUninstrument() +{ + LOG_FUNC_ENTRY("CATProject::RunUninstrument"); + // Read attributes. + if ( ! ReadAttributes() ) + return AT_RETURN_CODE::READ_ATTRIBUTES_ERROR; + // Init makefile member for this run mode. + if ( m_eBuildSystem == SBS_V1 ) + InitSbs1MakeFileWithPathToTemp(); + // Read makefile to get project attributes + if ( ! ReadMakeFile() ) + return AT_RETURN_CODE::READ_MAKEFILE_ERROR; + // Filter unsupported + FilterModules(); + // Check that we have some "valid" modules to hook + if ( m_vModules.size() == 0 &&( m_vUnsupportedModules.size() > 0 || m_vStaticLibraries.size() > 0 ) ) + return AT_RETURN_CODE::NO_SUPPORTED_MODULES_ERROR; + // Create lst files + if (! CreateListings() ) + return AT_RETURN_CODE::COMPILE_ERROR; + // Copy releasables of modules + if (! CopyReleasables() ) + return AT_RETURN_CODE::RELEASABLES_ERROR; + // Restore "unhook" modules + if (! RestoreModules() ) + return AT_RETURN_CODE::RESTORE_MODULES_ERROR; + // Return error code OK + return AT_RETURN_CODE::OK; +} + +int CATProject::RunUninstrumentConsole() +{ + LOG_FUNC_ENTRY("CATProject::RunUninstrumentConsole"); + int iErrorCode = AT_RETURN_CODE::OK; + // Read attributes + if ( ReadAttributes() ) + { + // Init makefile member for this run mode. + if ( m_eBuildSystem == SBS_V1 ) + InitSbs1MakeFileWithPathToTemp(); + // Read makefile to get project attributes + if( ReadMakeFile() ) + { + // Filter unsupported + FilterModules(); + // Create lst files + CreateListings(); + if (! CopyReleasables() ) + iErrorCode = AT_RETURN_CODE::RELEASABLES_ERROR; + } + else + iErrorCode = AT_RETURN_CODE::READ_MAKEFILE_ERROR; + // Change state to uninstrumented and write status + m_bUninstrumented = true; + if ( ! WriteAttributes() ) + iErrorCode = AT_RETURN_CODE::WRITE_ATTRIBUTES_ERROR; + } + else + { + iErrorCode = AT_RETURN_CODE::READ_ATTRIBUTES_ERROR; + } + return iErrorCode; +} + +int CATProject::RunUninstrumentFailed() +{ + LOG_FUNC_ENTRY("CATProject::RunUninstrumentFailed"); + // Read attributes. + if ( ! ReadAttributes() ) + return AT_RETURN_CODE::READ_ATTRIBUTES_ERROR; + // Init makefile member for this run mode. + if ( m_eBuildSystem == SBS_V1 ) + InitSbs1MakeFileWithPathToTemp(); + // Read makefile to get project attributes + if( ReadMakeFile() ) + { + // Filter modules + FilterModules(); + // Restore modules to make sure no changes left + if( RestoreModules() ) + { + // Delete temporary dirs of modules + if(! DeleteTemporaryDirs() ) + { + + } + + } + else + { + + } + } + else + { + + } + // Projects + if ( ! DirDelete( AT_TEMP_DIR, true ) ) + { + + } + return AT_RETURN_CODE::OK; +} + +// ---------------------------------------------------------------------------- +// Main Functions +// ---------------------------------------------------------------------------- +void CATProject::DisplayCompileSummary() +{ + LOG_FUNC_ENTRY("CATProject::DisplayCompileSummary"); + cout << AT_BUILD_SUMMARY_HEADER; + // Supported modules + for( size_t i = 0; i < m_vModules.size(); i++ ) + { + // Successful + if ( m_vModules.at(i)->GetErrors().empty() ) + { + // Create build complete file for Carbide xtension + m_vModules.at(i)->CreateBuildCompleteFile(); + cout << AT_BUILD_SUMMARY_INSTRUMENTED_BUILD_COMPLETE + << GetPathOrFileName( true, m_vModules.at(i)->GetMmpFile() ) + << endl + << AT_BUILD_SUMMARY_TARGET + << m_vModules.at(i)->GetBinaryName() + << endl; + // Datafiles + // Use module data file name if project's data file not defined. + if ( m_eLoggingMode == CATProject::FILE + && m_vModules.at(i)->GetTargetType().compare("exe") == 0 ) + { + if ( m_sS60FileName.empty() ) + cout << AT_BUILD_SUMMARY_DATA_FILE_NAME + << m_vModules.at(i)->GetS60FileName() + << endl; + else + cout << AT_BUILD_SUMMARY_DATA_FILE_NAME + << m_sS60FileName + << endl; + } + } + else + { + // Failed + cout << AT_BUILD_SUMMARY_FAILED + << GetPathOrFileName( true, m_vModules.at(i)->GetMmpFile() ) + << endl + << AT_BUILD_SUMMARY_TARGET + << m_vModules.at(i)->GetBinaryName() + << endl; + // Print errors. + cout << AT_BUILD_SUMMARY_ERRORS + << m_vModules.at(i)->GetErrors() + << endl; + } + } + + // Static libraries + for( size_t i = 0; i < m_vStaticLibraries.size(); i++ ) + { + if ( m_vStaticLibraries.at(i)->GetErrors().empty() ) + { + cout << AT_BUILD_SUMMARY_NORMAL_BUILD_COMPLETE + << GetPathOrFileName( true, m_vStaticLibraries.at(i)->GetMmpFile()) + << endl + << AT_BUILD_SUMMARY_TARGET + << m_vStaticLibraries.at(i)->GetBinaryName() + << endl + << AT_BUILD_SUMMARY_STATIC_LIBRARY + << endl; + + } + else + { + // Failed + cout << AT_BUILD_SUMMARY_FAILED + << GetPathOrFileName( true, m_vStaticLibraries.at(i)->GetMmpFile() ) + << endl + << AT_BUILD_SUMMARY_TARGET + << m_vStaticLibraries.at(i)->GetBinaryName() + << endl; + // Print errors. + cout << AT_BUILD_SUMMARY_ERRORS + << m_vStaticLibraries.at(i)->GetErrors() + << endl; + } + } + + // Unsupported modules + for( size_t i = 0; i < m_vUnsupportedModules.size(); i++ ) + { + cout << AT_BUILD_SUMMARY_NORMAL_BUILD_COMPLETE + << GetPathOrFileName( true, m_vUnsupportedModules.at(i)->GetMmpFile() ) + << endl + << AT_BUILD_SUMMARY_TARGET + << m_vUnsupportedModules.at(i)->GetBinaryName() + << endl; + cout << m_vUnsupportedModules.at(i)->GetCompileInfoText() << endl; + } +} + +void CATProject::DisplayBuildSummary( void ) +{ + LOG_FUNC_ENTRY("CATProject::DisplayBuildSummary"); + cout << endl; + // Build information + cout << AT_BUILD_SUMMARY_BUILD_TYPE << GetBuildTypeString() << endl; + // Platform + cout << AT_BUILD_SUMMARY_BUILD_PLATFORM << m_sPlatform << endl; + // Possible variant + if ( ! m_sVariant.empty() ) + cout << AT_BUILD_SUMMARY_BUILD_VARIANT << m_sVariant << endl; + // Logging mode + cout << AT_BUILD_SUMMARY_LOGGING_MODE; + if ( m_eLoggingMode == FILE ) + cout << AT_BUILD_SUMMARY_FILE; + else if ( m_eLoggingMode == TRACE ) + cout << AT_BUILD_SUMMARY_TRACE; + else if ( m_eLoggingMode == TRACE_FAST ) + cout << AT_BUILD_SUMMARY_TRACE_FAST; + cout << endl; + // Call stack sizes + cout << AT_BUILD_SUMMARY_ALLOC_CALL_STACK_SIZE + << m_iAllocCallStackSize + << endl; + cout << AT_BUILD_SUMMARY_FREE_CALL_STACK_SIZE + << m_iFreeCallStackSize + << endl; + + if(!_stricmp(m_sPlatform.c_str(), ("winscw"))) + { + //print version info only when version is not up-to-date + cout << endl; + showDbgHelpVersionInfo( false ); + } +} + +bool CATProject::CreateMakeFile() +{ + switch ( m_eBuildSystem ) + { + case SBS_V1: + if( ! CreateMakeFileSbs1() ) + return false; + // Copy main make file. + if( ! CopyMakeFileSbs1ToTemporaryFolder() ) + return false; + // Run export. + if( ! RunExportSbs1() ) + return false; + // Create level 2 makefiles. + if( ! CreateMakeFileSbs1Level2() ) + return false; + return true; + case SBS_V2: + return CreateMakeFileSbs2(); + default: + return false; + } +} + +bool CATProject::CreateMakeFileSbs1() +{ + LOG_FUNC_ENTRY("CATProject::CreateMakeFileSbs1"); + + // If variant defined check does it exist. + if( ! m_sVariant.empty() ) + { + if ( ! CheckVariant( m_sEpocRoot, m_sVariant ) ) + { + cout << INVALID_VARIANT_ERROR; + if ( IsDefaultVariant( m_sEpocRoot ) ) + { + m_sVariant = "default"; + cout << USING_DEFAULT_VARIANT_MESSAGE; + if ( ! WriteAttributes() ) + return false; + } + else + { + cout << NO_DEFAULT_VARIANT_ERROR; + return false; + } + } + } + + // Create level 1 make file. + string sCmd( "bldmake bldfiles " ); + sCmd.append( m_sPlatform ); + cout << AT_MSG_SYSTEM_CALL << sCmd << endl; + (void)system( sCmd.c_str() ); + return InitSbs1MakeFileWithPath(); +} + +bool CATProject::CopyMakeFileSbs1ToTemporaryFolder() +{ + LOG_FUNC_ENTRY("CATProject::CopyMakeFileSbs1ToTemporaryFolder"); + // Check that temporary dir exists if not create it. + if ( ! MakeTempDirIfNotExist() ) + return false; + // Copy makefile to temporary directory + string sMakeFileInTemp( AT_TEMP_DIR ); + sMakeFileInTemp.append( "\\" ); + sMakeFileInTemp.append( AT_LEVEL_1_MAKEFILE_NAME ); + if ( ! FileCopyToPath( m_sMakeFile, sMakeFileInTemp ) ) + return false; + return true; + +} + +bool CATProject::RunReallyCleanSbs1() +{ + LOG_FUNC_ENTRY("CATProject::RunReallyCleanSbs1"); + // Check that abld.bat has been made. + if ( ! FileExists( "abld.bat" ) ) + return false; + // Run reallyclean. + string sCmd; + if ( m_bAbldTest ) + sCmd = "abld test reallyclean "; + else + sCmd = "abld reallyclean "; + sCmd.append( m_sPlatform ); + if ( ! m_sVariant.empty() ) + { + sCmd.append( "." ); + sCmd.append( m_sVariant ); + } + sCmd.append( " " ); + sCmd.append( GetBuildTypeString() ); + if ( m_vTargetModules.size() > 1 ) + { + RunAbldCommandToAllTargets( sCmd ); + } + else + { + AddTargetModuleIfDefined( sCmd ); + cout << AT_MSG_SYSTEM_CALL << sCmd << endl; + (void) system( sCmd.c_str() ); + } + return true; +} + +bool CATProject::RunReallyCleanSbs2() +{ + LOG_FUNC_ENTRY("CATProject::RunReallyCleanSbs2"); + string sCmd(""); + if ( m_sBuildCommand.empty() ) + { + // If no build command defined (not found in project.cfg). + sCmd.append( RAPTOR_CMD_BASE );; + sCmd.append( m_sPlatform ); + sCmd.append( "_" ); + sCmd.append( GetBuildTypeString() ); + if ( ! m_sVariant.empty() ) + { + sCmd.append( "." ); + sCmd.append( m_sVariant ); + } + sCmd.append( RAPTOR_REALLYCLEAN_LOG ); + AddTargetModuleIfDefined( sCmd ); + sCmd.append( " REALLYCLEAN" ); + } + else + { + // When build command set use it. + sCmd.append( m_sBuildCommand ); + sCmd.append( RAPTOR_REALLYCLEAN_LOG ); + sCmd.append( " REALLYCLEAN" ); + } + cout << AT_MSG_SYSTEM_CALL << sCmd << endl; + int iRet = (int)system( sCmd.c_str() ); + if ( iRet == 0 ) + return true; + return false; +} + +bool CATProject::RunExportSbs1() +{ + LOG_FUNC_ENTRY("CATProject::RunExportSbs1"); + // Run export. + string sCmd; + if ( m_bAbldTest ) + sCmd = "abld test export"; + else + sCmd = "abld export"; + cout << AT_MSG_SYSTEM_CALL << sCmd << endl; + (void) system( sCmd.c_str() ); + return true; +} + +bool CATProject::CreateMakeFileSbs1Level2() +{ + LOG_FUNC_ENTRY("CATProject::CreateMakeFileSbs1Level2"); + // Create level 2 makefiles. + + string sCmd; + + if ( m_bAbldTest ) + sCmd ="abld test makefile "; + else + sCmd ="abld makefile "; + + sCmd.append( m_sPlatform ); + if ( ! m_sVariant.empty() ) + { + sCmd.append( "." ); + sCmd.append( m_sVariant ); + } + + // Check if multiple targets defined and sbs 1. + if ( m_vTargetModules.size() > 1 ) + { + RunAbldCommandToAllTargets( sCmd ); + } + else + { + AddTargetModuleIfDefined( sCmd ); + cout << AT_MSG_SYSTEM_CALL << sCmd << endl; + (void) system( sCmd.c_str() ); + } + return true; +} + +bool CATProject::CreateMakeFileSbs2() +{ + LOG_FUNC_ENTRY("CATProject::CreateMakeFileSbs2"); + // Delete build directory if it exists before creating new makefiles. + if ( DirectoryExists( "atool_temp\\build" ) ) + DirDelete( "atool_temp\\build", true ); + // Create command to create makefiles. + string sCmd( m_sBuildCommand ); + sCmd.append( " " ); + sCmd.append( RAPTOR_MAKEFILE_SWITCH ); + sCmd.append( " " ); + sCmd.append( RAPTOR_NOBUILD_SWITCH ); + cout << AT_MSG_SYSTEM_CALL << sCmd << endl; + int iRet = (int)system( sCmd.c_str() ); + if ( iRet == 0 ) + return true; + return false; +} + +bool CATProject::ReadMakeFile() +{ + // Clean modules before reading. + CleanModuleVectors(); + if ( m_eBuildSystem == SBS_V1 ) + { + // Read level 1 makefile which contains module name and makefiles. + if( ! ReadMakeFileSbs1Level1() ) + return false; + // Read level 2 makefiles. + vector::iterator it; + // If we are compiling or etc... we need to create temporary directories. + if ( m_eMode == COMPILE || m_eMode == INSTRUMENT || m_eMode == INSTRUMENT_CONSOLE ) + { + // Read make makefiles from /epoc32/build... and create temporary directory. + bool bLevel2 = true; + for( it = m_vModules.begin(); it != m_vModules.end() ; it ++ ) + { + if( ! (*it)->CreateTemporaryDirectory() ) + return false; + if( ! (*it)->ReadMakeFile() ) + { + bLevel2 = false; + break; + } + } + // If failed reading modules from level 2 makefiles. + if ( ! bLevel2 ) + { + // Clean modules. + CleanModuleVectors(); + // Try use default variant if it exists. + if ( CheckVariant( m_sEpocRoot, "default" ) ) + { + m_sVariant = "default"; + cout << USING_DEFAULT_VARIANT_MESSAGE; + if ( ! WriteAttributes() ) + return false; + if ( ! InitSbs1MakeFileWithPath() ) + return false; + if ( ! ReadMakeFileSbs1Level1() ) + return false; + for( it = m_vModules.begin(); it != m_vModules.end() ; it ++ ) + { + if( ! (*it)->CreateTemporaryDirectory() ) + return false; + if( ! (*it)->ReadMakeFile() ) + return false; + } + + } + } + } + else + { + // Read make files from temporary directories. + for( it = m_vModules.begin(); it != m_vModules.end() ; it ++ ) + { + if ( ! (*it)->ReadMakeFileFromTemp() ) + return false; + } + } + return true; + } + else if ( m_eBuildSystem == SBS_V2 ) + { + // Read make file. + if( ! ReadMakeFileSbs2() ) + return false; + // Create module temporary directories if we are compiling or etc... + if ( m_eMode == COMPILE || m_eMode == INSTRUMENT || m_eMode == INSTRUMENT_CONSOLE ) + { + for( vector::iterator it = m_vModules.begin(); it < m_vModules.end(); it++ ) + (*it)->CreateTemporaryDirectory(); + for( vector::iterator it = m_vStaticLibraries.begin(); it < m_vStaticLibraries.end(); it++ ) + (*it)->CreateTemporaryDirectory(); + } + } + return true; +} + +bool CATProject::ReadMakeFileSbs1Level1() +{ + LOG_FUNC_ENTRY("CATProject::ReadMakeFileSbs1Level1"); + + bool bRet = false; + + //Try to open makefile + ifstream in; + in.open( m_sMakeFile.c_str() ); + + //File open ok? + if( !in.good() ) + { + printf( "Can not open file: %s\n", m_sMakeFile.c_str() ); + in.close(); + return bRet; + } + + // Add also these so "compatible with sbs2". + // Releasables path (binaries). + string sReleasePath( m_sEpocRoot ); + // add trailing '\' if root path is missing it + if ( sReleasePath.size() < 1 ) + sReleasePath.append( "\\" ); + else if ( sReleasePath.at( sReleasePath.length() -1 ) != '\\' ) + sReleasePath.append( "\\" ); + sReleasePath.append( "epoc32\\release" ); + string sFullVariantPath( m_sPlatform ); + sFullVariantPath.append( "\\" ); + sFullVariantPath.append( GetBuildTypeString() ); + + char cTemp[MAX_LINE_LENGTH]; + bool bContinueSearch = true; + bool bMmpInfoFound = false; + CATModule2* pModule = 0; + string sTempLineFromFile; + string sMmpFileSearchString; + if ( m_bAbldTest ) + sMmpFileSearchString = MMPTESTFILE_SEARCH_STRING; + else + sMmpFileSearchString = MMPFILE_SEARCH_STRING; + do + { + // get line from file + in.getline( cTemp, MAX_LINE_LENGTH ); + sTempLineFromFile.clear(); + sTempLineFromFile.append( cTemp ); + + //Search makefile string + if( sTempLineFromFile.find( MAKEFILE_SEARCH_STRING ) != string::npos ) + { + bMmpInfoFound = true; + if( sTempLineFromFile.find( sMmpFileSearchString ) != string::npos ) + { + bRet = true; + //Parse mmp path + mmp filename + sTempLineFromFile.erase( 0, sTempLineFromFile.find_first_of("\"") ); + sTempLineFromFile.erase( 0, 1 ); + + string sPath = sTempLineFromFile.substr(0, sTempLineFromFile.find_first_of("\"") ); + + sPath = ChangeSlashToBackSlash( sPath ); + //Remove text "bld.inf" + sPath.erase( (sPath.find_last_of( "\\" ) + 1) , string::npos ); + + string sFileName = sTempLineFromFile.substr( (sTempLineFromFile.find( sMmpFileSearchString ) + sMmpFileSearchString.length() + 3), string::npos ); + sFileName = ChangeSlashToBackSlash( sFileName ); + sFileName = sFileName.substr( 0, sFileName.find_first_of("\"") ); + + // Append .mmp to filename if it does not exist + if ( sFileName.find(".mmp") == string::npos ) + sFileName.append(".mmp"); + + //Insert drive letter + sPath.insert(0, string( m_cCurrentDir).substr(0,2) ); + + //Insert mmp file to the end + sPath.append( sFileName ); + + ChangeToLower( sPath ); + + // If target programs defined find from those or do not + // add module to vector. + bool bAddToVector = true; + if ( m_vTargetModules.size() > 0 ) + { + bAddToVector = false; + vector::iterator it; + for( it = m_vTargetModules.begin() ; it != m_vTargetModules.end() ; it++ ) + { + string sFind( *it ); + sFind.insert( 0, "\\" ); + if ( sPath.find( sFind ) != string::npos ) + { + bAddToVector = true; + break; + } + } + } + + if ( bAddToVector ) + { + pModule = new CATModule2(); + pModule->SetMmpFile( sPath ); + pModule->SetVariantType( GetBuildTypeString() ); + pModule->SetVariantPlatform( m_sPlatform ); + pModule->SetReleasePath( sReleasePath ); + pModule->SetFullVariantPath( sFullVariantPath ); + pModule->SetBuildSystem( SBS_V1 ); + m_vModules.push_back( pModule ); + } + } + } + else if( bMmpInfoFound ) + //Do not continue search if mmp info lines are all handled + bContinueSearch = false; + if( !in.good() ) + bContinueSearch = false; + } + while( bContinueSearch ); + + bContinueSearch = true; + + //Search MAKEFILES for invidual modules + do + { + in.getline( cTemp, MAX_LINE_LENGTH ); + sTempLineFromFile.clear(); + sTempLineFromFile.append( cTemp ); + // find the lines 'MAKEFILE[modulename]_FILES' + if( (sTempLineFromFile.find( "MAKEFILE" ) == 0) && (sTempLineFromFile.find( "_FILES" ) != string::npos) ) + { + //Math the makefile line with one of our modules + for( size_t i = 0 ; i < m_vModules.size() ; i++ ) + { + //Create name + string sMakeFile( "MAKEFILE" ); + string sTempMmpFile( RemovePathAndExt( m_vModules.at(i)->GetMmpFile(), true ) ); + ChangeToUpper( sTempMmpFile ); + sMakeFile.append( sTempMmpFile ); + sMakeFile.append( "_FILES" ); + // matched + if( sTempLineFromFile.find( sMakeFile ) != string::npos ) + { + //parse the makefile name from line + in.getline( cTemp, MAX_LINE_LENGTH ); + sTempLineFromFile.clear(); + sTempLineFromFile.append( cTemp ); + //Remove character "\"" + sTempLineFromFile.erase( 0, ( sTempLineFromFile.find_first_of("\"") + 1 ) ); + // in winscw last part is '" \' and on armd '"' so remove all after last '"' + sTempLineFromFile.erase( sTempLineFromFile.find_last_of("\""), sTempLineFromFile.size() ); + // Set correct makefile for module + m_vModules.at( i )->SetMakeFile( sTempLineFromFile ); + // break + break; + } // If mathed to mmp + } // End of mmp file loop + } // found lines 'MAKEFILE[modulename]_FILES' + if( !in.good() ) + bContinueSearch = false; + } + while( bContinueSearch ); + in.close(); + return bRet; +} + +bool CATProject::ReadMakeFileSbs2( void ) +{ + LOG_FUNC_ENTRY("CATProject::ReadMakeFileSbs2(void)"); + // File is by default named make_build.default but when building specific layer + // make_build_LAYERNAME.default is produced by Raptor. + // So find makefile(s) and read them. + vector vMakeFiles = DirList( "atool_temp\\build\\", false, true ); + bool bRet = true; + for( vector::iterator it = vMakeFiles.begin(); it != vMakeFiles.end() ; it++ ) + { + // Recognize multiple makefiles. + if ( it->find("make_build_") != string::npos && it->find(".default") != string::npos ) + { + if ( ! ReadMakeFileSbs2( *it ) ) + bRet = false; + } + // Single makefile. + else if ( it->find( "make_build.default" ) != string::npos ) + { + if ( ! ReadMakeFileSbs2( *it ) ) + bRet = false; + } + } + // We got some modules? + if ( m_vModules.size() == 0 ) + bRet = false; + return bRet; +} + +bool CATProject::ReadMakeFileSbs2( string& sMakeFile ) +{ + LOG_FUNC_ENTRY("CATProject::ReadMakeFileSbs2(string)"); + try { + // Open file + ifstream in; + in.open( sMakeFile.c_str() , ios_base::in ); + // Check that open ok + if ( ! in.good() ) + { + cout << AT_MSG << "Error, opening file " + << RAPTOR_MAKEFILE << endl; + in.close(); + return false; + } + // Source line from file + string sSourceLine; + // Module pointer + CATModule2* pModule = 0; + // Are we looking for module attributes + bool bFindAttributes = false; + // Until end of file + while( in.good() ) + { + // Get new line from file + string sLine; + getline(in, sLine); + // New module + if ( sLine.find( RAPTOR_PROJECT_META ) == 0 ) + { + // Remove project_meta from line + sLine.erase(0, strlen( RAPTOR_PROJECT_META ) ); + LOG_STRING("Found module: " << sLine ); + // Check is name empty + // This seems to happen when sbs2 "wraps" i.e. mifconv to a module type item + if ( sLine.empty() ) + { + LOG_STRING("skipping empty module"); + // Skip it + continue; + } + // If module add it to vector + if ( pModule ) + { + // Add sources, + pModule->AddSources( sSourceLine ); + // Build system. + pModule->SetBuildSystem( SBS_V1 ); + // Push to vector. + m_vModules.push_back( pModule ); + } + // New module + pModule = new CATModule2(); + // Clear sourceline + sSourceLine.clear(); + // Set modules mmp with path + + if ( ! pModule->SetMmpFile( sLine ) ) + { + // Fatal error setting mmp file + in.close(); + return false; + } + // Find attributes on + bFindAttributes = true; + // Get new line from file + getline(in, sLine); + } + // If attribute finding on + if ( bFindAttributes ) + { + // Pickup modules attributes + if ( sLine.find ( RAPTOR_SOURCE ) == 0 ) + { + sLine.erase(0, strlen( RAPTOR_SOURCE ) ); + sSourceLine = sLine; + } + else if ( sLine.find ( RAPTOR_TARGET ) == 0 ) + { + sLine.erase(0, strlen( RAPTOR_TARGET ) ); + pModule->SetTarget( sLine ); + } + else if ( sLine.find ( RAPTOR_TARGETYPE ) == 0 ) + { + sLine.erase(0, strlen( RAPTOR_TARGETYPE )); + pModule->SetTargetType( sLine ); + } + else if ( sLine.find( RAPTOR_REQUESTEDTARGETEXT ) == 0 ) + { + sLine.erase(0, strlen( RAPTOR_REQUESTEDTARGETEXT ) ); + pModule->SetRequestedTargetExt( sLine ); + } + else if ( sLine.find ( RAPTOR_VARIANTPLATFORM ) == 0 ) + { + sLine.erase(0, strlen( RAPTOR_VARIANTPLATFORM )); + pModule->SetVariantPlatform( sLine ); + } + else if ( sLine.find ( RAPTOR_VARIANTTYPE ) == 0 ) + { + sLine.erase(0, strlen( RAPTOR_VARIANTTYPE )); + pModule->SetVariantType( sLine ); + } + else if ( sLine.find ( RAPTOR_FEATUREVARIANT ) == 0 ) + { + sLine.erase(0, strlen( RAPTOR_FEATUREVARIANT )); + pModule->SetFeatureVariant( sLine ); + } + else if ( sLine.find ( RAPTOR_FEATUREVARIANTNAME ) == 0 ) + { + sLine.erase(0, strlen( RAPTOR_FEATUREVARIANTNAME )); + pModule->SetFeatureVariantName( sLine ); + } + else if ( sLine.find ( RAPTOR_RELEASEPATH ) == 0 ) + { + sLine.erase(0, strlen( RAPTOR_RELEASEPATH )); + pModule->SetReleasePath( sLine ); + } + else if ( sLine.find ( RAPTOR_FULLVARIANTPATH ) == 0 ) + { + sLine.erase(0, strlen( RAPTOR_FULLVARIANTPATH )); + pModule->SetFullVariantPath( sLine ); + } + else if ( sLine.find ( RAPTOR_COMPILE_DEFINITIONS ) == 0 ) + { + sLine.erase(0, strlen( RAPTOR_COMPILE_DEFINITIONS ) ); + pModule->SetCompileDefinitions( sLine ); + } + } + } // while in.good() + // Add last module if n number of modules found + if ( pModule ) + { + if ( ! pModule->GetTarget().empty() ) + { + // Add sources + pModule->AddSources( sSourceLine ); + // Build system. + pModule->SetBuildSystem( SBS_V1 ); + // Push back to vector + m_vModules.push_back( pModule ); + } + } + // Close file + in.close(); + return true; + } // try. + catch(...) + { + LOG_STRING("Unexpected exception reading sbs 2 makefile"); + return false; + } +} +bool CATProject::CreateTemporaryDirectories() +{ + LOG_FUNC_ENTRY("CATProject::CreateTemporaryDirectories"); + bool bRet = true; + for( size_t i = 0 ; i < m_vModules.size(); i++) + { + if( ! m_vModules.at(i)->CreateTemporaryDirectory() ) + bRet = false; + } + for( size_t i = 0 ; i < m_vStaticLibraries.size(); i++) + { + if( ! m_vStaticLibraries.at(i)->CreateTemporaryDirectory() ) + bRet = false; + } + return bRet; + +} + +bool CATProject::CreateTemporaryCpps() +{ + LOG_FUNC_ENTRY("CATProject::CreateTemporaryCpps"); + bool bRet = true; + for( size_t i = 0 ; i < m_vModules.size(); i++) + { + if( ! m_vModules.at(i)->CreateTempCpp( + m_sS60FileName, m_eLoggingMode, m_eBuildType, m_iAllocCallStackSize, m_iFreeCallStackSize ) ) + bRet = false; + } + return bRet; +} + +bool CATProject::FilterModules() +{ + LOG_FUNC_ENTRY("CATProject::FilterModules"); + vector::iterator it; + // Loop thru modules. + it = m_vModules.begin(); + while( it != m_vModules.end() ) + { + // Get target type of module to separate string (will be modified). + string sTargetType = (*it)->GetTargetType(); + // Modules compile definitions. + string sCompileDefinition = (*it)->GetCompileDefinitions(); + // Check is it supported. + if ( !IsTargetTypeSupported( sTargetType) ) + { + (*it)->SetCompileInfoText( AT_UNSUPPORTED_TARGET_TYPE ); + // Not supported add to not supported vector. + m_vUnsupportedModules.push_back( *it ); + // Erase cell. + it = m_vModules.erase( it ); + } + // Check if its static library + else if ( _stricmp( sTargetType.c_str(), "lib" ) == 0 ) + { + // Static librarie move to their vector. + m_vStaticLibraries.push_back( *it ); + // Erase cell. + it = m_vModules.erase( it ); + + } + else if ( sCompileDefinition.find( KERNEL_MODE_COMPILE_DEFINITION ) != string::npos ) + { + (*it)->SetCompileInfoText( AT_UNSUPPORTED_COMPILE_DEFINITION ); + // Not supported add to not supported vector. + m_vUnsupportedModules.push_back( *it ); + // Erase cell. + it = m_vModules.erase( it ); + } + else + it++; + } + return true; +} + +bool CATProject::ModifyModules() +{ + LOG_FUNC_ENTRY("CATProject::ModifyModules"); + bool bRet = true; + for( size_t i = 0; i < m_vModules.size(); i++ ) + { + if (! m_vModules.at(i)->ModifyMmp() ) + bRet = false; + } + for( size_t i = 0; i < m_vStaticLibraries.size(); i++ ) + { + if (! m_vStaticLibraries.at(i)->ModifyMmp() ) + bRet = false; + } + return bRet; +} + +bool CATProject::RestoreModules() +{ + LOG_FUNC_ENTRY("CATProject::RestoreModules"); + bool bRet = true; + for( size_t i = 0; i < m_vModules.size(); i++ ) + { + if (! m_vModules.at(i)->RestoreMmp() ) + bRet = false; + } + for( size_t i = 0; i < m_vStaticLibraries.size(); i++ ) + { + if (! m_vStaticLibraries.at(i)->RestoreMmp() ) + bRet = false; + } + return bRet; +} + +bool CATProject::VerifyAndRecoverModules() +{ + LOG_FUNC_ENTRY("CATProject::VerifyAndRecoverModules"); + bool bRet = true; + for( size_t i = 0; i < m_vModules.size(); i++ ) + { + if (! m_vModules.at(i)->VerifyAndRecoverMmp() ) + bRet = false; + } + for( size_t i = 0; i < m_vStaticLibraries.size(); i++ ) + { + if (! m_vStaticLibraries.at(i)->VerifyAndRecoverMmp() ) + bRet = false; + } + return bRet; +} +bool CATProject::Compile() +{ + switch ( m_eBuildSystem ) + { + case SBS_V1: + // Run Reallyclean. + if( ! RunReallyCleanSbs1() ) + return false; + return CompileSbs1(); + case SBS_V2: + return CompileSbs2(); + default: + return false; + } +} + +bool CATProject::CompileSbs1() +{ + LOG_FUNC_ENTRY("CATProject::CompileSbs1"); + string sCommand(""); + if ( m_sBuildCommand.empty() ) + { + sCommand = "abld build"; + // -debug if urel + if ( m_eBuildType == UREL ) + sCommand.append( " -debug" ); + + // No variant + if ( m_sVariant.empty() ) + { + sCommand.append( " " ); + sCommand.append( m_sPlatform ); + } + else + { + // Add variant + sCommand.append( " " ); + sCommand.append( m_sPlatform ); + sCommand.append( "." ); + sCommand.append( m_sVariant ); + } + + // urel vs udeb + sCommand.append( " " ); + sCommand.append( GetBuildTypeString() ); + + // Possible target module + AddTargetModuleIfDefined( sCommand ); + } + // Check that build command contains -debug switch if sbs v.1 used + else if ( ! m_sBuildCommand.empty() + && m_eBuildType == UREL + && m_eBuildSystem == SBS_V1 + && m_sBuildCommand.find( "-debug" ) == string::npos ) + { + // Find correct index to insert -debug switch + size_t iPos = m_sBuildCommand.find( "build" ); + if ( iPos != string::npos ) + { + sCommand = m_sBuildCommand; + sCommand.insert( iPos+5, " -debug" ); + } + else + { + LOG_STRING("Overwriting given build command to add -debug switch. Original command is: " << m_sBuildCommand ); + if ( m_bAbldTest ) + sCommand = "abld test build -debug "; + else + sCommand = "abld build -debug "; + // No variant + if ( m_sVariant.empty() ) + { + sCommand.append( m_sPlatform ); + } + else + { + // Add variant + sCommand.append( m_sPlatform ); + sCommand.append( "." ); + sCommand.append( m_sVariant ); + } + + // urel vs udeb + sCommand.append( " " ); + sCommand.append( GetBuildTypeString() ); + // Possible target module + AddTargetModuleIfDefined( sCommand ); + } + } + else + sCommand = m_sBuildCommand; + // Run command + cout << AT_MSG_SYSTEM_CALL << sCommand << endl; + (void)system( sCommand.c_str() ); + return true; +} + +bool CATProject::CompileSbs2() +{ + LOG_FUNC_ENTRY("CATProject::CompileSbs2"); + // Create command to compile with raptor + string sCmd( m_sBuildCommand ); + sCmd.append( RAPTOR_BUILD_LOG ); + cout << AT_MSG_SYSTEM_CALL << sCmd << endl; + int iRet = (int)system( sCmd.c_str() ); + if ( iRet == 0 ) + return true; + return false; +} + +bool CATProject::CreateListings() +{ + // Create listings if no addr2line defined + #ifndef ADDR2LINE + if ( _stricmp( m_sPlatform.c_str(), "armv5" ) == 0 ) + { + switch ( m_eBuildSystem ) + { + case SBS_V1: + return CreateListingsSbs1(); + case SBS_V2: + return CreateListingsSbs2(); + default: + return false; + } + } + #endif + return true; +} + +bool CATProject::CreateListingsSbs1() +{ + LOG_FUNC_ENTRY("CATProject::CreateListingsSbs1"); + string sCommand; + if ( m_bAbldTest ) + sCommand = "abld test listing "; + else + sCommand = "abld listing "; + + // Listing + if ( m_sVariant.empty() ) + { + // No variant + sCommand.append( m_sPlatform ); + } + else + { + // Use specified variant + sCommand.append( m_sPlatform ); + sCommand.append( "." ); + sCommand.append( m_sVariant ); + } + // udeb vs urel + sCommand.append( " " ); + sCommand.append( GetBuildTypeString() ); + + if ( m_vTargetModules.size() > 1 ) + { + RunAbldCommandToAllTargets( sCommand ); + } + else + { + AddTargetModuleIfDefined( sCommand ); + cout << AT_MSG_SYSTEM_CALL << sCommand << endl; + (void)system( sCommand.c_str() ); + } + return true; +} + +bool CATProject::CreateListingsSbs2() +{ + LOG_FUNC_ENTRY("CATProject::CreateListingsSbs2"); + string sCmd( m_sBuildCommand ); + sCmd.append( RAPTOR_LISTING_LOG ); + sCmd.append( " LISTING"); + cout << AT_MSG_SYSTEM_CALL << sCmd << endl; + int iRet = (int)system( sCmd.c_str() ); + if ( iRet == 0 ) + return true; + return false; +} + +bool CATProject::CopyReleasables() +{ + bool bRet = true; + LOG_FUNC_ENTRY("CATProject::CopyReleasables"); + // Only copy releasables on armv5 platform and no addr2line defined. + #ifndef ADDR2LINE + if ( _stricmp( m_sPlatform.c_str(), "armv5" ) == 0 ) + { + for( size_t i = 0; i < m_vModules.size(); i++ ) + { + if ( ! m_vModules.at(i)->CopyReleasables() ) + bRet = false; + } + // Static libraries lst files. + // First create directory for them (delete old one if exists). + if ( ! DirectoryExists( AT_TEMP_LST_DIR ) ) + { + DirCreate( AT_TEMP_LST_DIR, true ); + } + else + { + DirDelete( AT_TEMP_LST_DIR, true ); + DirCreate( AT_TEMP_LST_DIR, true ); + } + for ( size_t i = 0 ; i < m_vStaticLibraries.size(); i ++ ) + { + if( ! m_vStaticLibraries.at(i)->CopyLstFilesToDir( AT_TEMP_LST_DIR ) ) + bRet = false; + } + + // Delete lst files from all type of modules in project. + // Ignoring errors because different modules might use same source/lst files. + for( size_t i = 0; i < m_vModules.size(); i++ ) + m_vModules.at(i)->DeleteLstFilesFromSrc(); + for ( size_t i = 0 ; i < m_vUnsupportedModules.size(); i ++ ) + m_vUnsupportedModules.at(i)->DeleteLstFilesFromSrc(); + for ( size_t i = 0 ; i < m_vStaticLibraries.size(); i ++ ) + m_vStaticLibraries.at(i)->DeleteLstFilesFromSrc(); + + return bRet; + } + #endif + // When addr2line defined and used we use symbol and map file(s). + #ifdef ADDR2LINE + if ( _stricmp( m_sPlatform.c_str(), "armv5" ) == 0 ) + { + // Verify that module(s) symbol file(s) exist + for( size_t i = 0; i < m_vModules.size(); i++ ) + { + // Check symbol file. + if ( ! m_vModules.at(i)->SymbolFileExist() ) + bRet = false; + // Check map file. + if ( ! m_vModules.at(i)->MapFileExist() ) + bRet = false; + } + } + #endif + // Platform winscw. + else if ( _stricmp( m_sPlatform.c_str(), "winscw" ) == 0 ) + { + // Verify that module(s) binaries exist + for( size_t i = 0; i < m_vModules.size(); i++ ) + { + if ( ! m_vModules.at(i)->BinaryFileExist() ) + bRet = false; + } + // For static libraries binary/target is same as their library. + for ( size_t i = 0 ; i < m_vStaticLibraries.size(); i ++ ) + if ( ! m_vStaticLibraries.at(i)->BinaryFileExist() ) + bRet = false; + } + // Platform gcce. + else if ( _stricmp( m_sPlatform.c_str(), "gcce" ) == 0 ) + { + // Verify that module(s) symbol file(s) exist + for( size_t i = 0; i < m_vModules.size(); i++ ) + { + // Check symbol file. + if ( ! m_vModules.at(i)->SymbolFileExist() ) + bRet = false; + } + } + return bRet; +} + +// ---------------------------------------------------------------------------- +// Write project's (user) attributes to a file under temp folder +// ---------------------------------------------------------------------------- +bool CATProject::WriteAttributes() const +{ + LOG_FUNC_ENTRY("CATProject::WriteAttributes"); + // File to write to + string sOutFile( AT_TEMP_DIR ); + sOutFile.append( "\\" ); + sOutFile.append( AT_PROJECT_ATTRIBUTES_FILE_NAME ); + // Open file truncate if exists + ofstream out( sOutFile.c_str(), ios_base::trunc ); + // Check file opened successfully + if ( ! out.good() ) + return false; + // Write attributes line by line + out << m_bUninstrumented << endl; // Is project instrumented + // Sbs version + if ( m_eBuildSystem == CATProject::SBS_V2 ) + out << "SBS_2" << endl; + else + out << "SBS_1" << endl; + out << endl; // Reserved for possible binary data + out << m_sPlatform << endl; + out << m_sVariant << endl; + out << m_eLoggingMode << endl; + out << m_eBuildType << endl; + out << m_sS60FileName << endl; + out << m_iAllocCallStackSize << endl; + out << m_iFreeCallStackSize << endl; + for ( size_t i = 0 ; i < m_vTargetModules.size() ; i++ ) + out << m_vTargetModules.at(i) << AT_PROJECT_ATTRIBUTES_SEPARATOR; + out << endl; + out << m_sBuildCommand << endl; + out.close(); + return true; +} +// ---------------------------------------------------------------------------- +// Reads project's (user) attributes to a file under temp folder +// ---------------------------------------------------------------------------- +bool CATProject::ReadAttributes() +{ + LOG_FUNC_ENTRY("CATProject::ReadAttributes"); + // File to read on + string sInFile( AT_TEMP_DIR ); + sInFile.append( "\\" ); + sInFile.append( AT_PROJECT_ATTRIBUTES_FILE_NAME ); + // Open file + ifstream in( sInFile.c_str() ); + // Check file opened successfully + if ( ! in.good() ) + return false; + // Read attributes + char cLine[ MAX_LINE_LENGTH ]; + string sLine; + in.getline( cLine, MAX_LINE_LENGTH ); + int iValue = atoi( cLine ); + if ( iValue == 1 ) + m_bUninstrumented = true; + else + m_bUninstrumented = false; + // Sbs version + in.getline( cLine, MAX_LINE_LENGTH ); string sBuildSystem = string( cLine ); + if ( sBuildSystem.compare( "SBS_1" ) == 0 ) + m_eBuildSystem = CATProject::SBS_V1; + else if ( sBuildSystem.compare( "SBS_2" ) == 0 ) + m_eBuildSystem = CATProject::SBS_V2; + else { + LOG_STRING("Error invalid build system defined in project.cfg"); + m_eBuildSystem = CATProject::SBS_V1; + } + in.getline( cLine, MAX_LINE_LENGTH ); // reserverd for possible binary timestamp or similar + in.getline( cLine, MAX_LINE_LENGTH ); m_sPlatform = string( cLine ); + in.getline( cLine, MAX_LINE_LENGTH ); m_sVariant = string( cLine ); + in.getline( cLine, MAX_LINE_LENGTH ); m_eLoggingMode = atoi( cLine ); + in.getline( cLine, MAX_LINE_LENGTH ); m_eBuildType = atoi( cLine ); + in.getline( cLine, MAX_LINE_LENGTH ); m_sS60FileName = string( cLine ); + in.getline( cLine, MAX_LINE_LENGTH ); m_iAllocCallStackSize = atoi( cLine ); + in.getline( cLine, MAX_LINE_LENGTH ); m_iFreeCallStackSize = atoi( cLine ); + in.getline( cLine, MAX_LINE_LENGTH ); sLine = cLine; + size_t iSpot = sLine.find( AT_PROJECT_ATTRIBUTES_SEPARATOR ); + while ( iSpot != string::npos ) + { + string sTarget = sLine.substr(0, iSpot ); + m_vTargetModules.push_back( sTarget ); + sLine.erase(0, iSpot + AT_PROJECT_ATTRIBUTES_SEPARATOR.size() ); + iSpot = sLine.find( AT_PROJECT_ATTRIBUTES_SEPARATOR ); + } + in.getline( cLine, MAX_LINE_LENGTH ); m_sBuildCommand = cLine; + in.close(); + return true; +} + +// ---------------------------------------------------------------------------- +// Creates atool_temp directory to current folder if does not exist +// ---------------------------------------------------------------------------- +bool CATProject::MakeTempDirIfNotExist() +{ + LOG_FUNC_ENTRY("CATProject::MakeTempDirIfNotExist"); + if ( ! DirectoryExists( AT_TEMP_DIR ) ) + { + if( !CreateDirectory( AT_TEMP_DIR , NULL ) ) + { + return false; + } + } + return true; +} +// ---------------------------------------------------------------------------- +// Utilities +// ---------------------------------------------------------------------------- + +bool CATProject::RunAbldCommandToAllTargets( const string& sCommand ) +{ + LOG_FUNC_ENTRY("CATProject::RunAbldCommandToAllTargets"); + + // Check for space at the commands end. + string sSystemCall( sCommand ); + if ( *(sSystemCall.rbegin()) != ' ' ) + sSystemCall.append( " " ); + + // Loop calls. + bool bRet = true; + for ( vector::iterator it = m_vTargetModules.begin(); it < m_vTargetModules.end(); it++ ) + { + string sCall( sSystemCall ); + sCall.append( RemovePathAndExt( *it, true ) ); + cout << AT_MSG_SYSTEM_CALL << sCall << endl; + if ( (int) system( sCall.c_str() ) != 0 ) + bRet = false; + } + return bRet; +} + +void CATProject::AddTargetModuleIfDefined( string& sCmd ) +{ + LOG_FUNC_ENTRY("CATProject::AddTargetModuleIfDefined"); + // Do we have target modules defined + if ( m_vTargetModules.size() > 0 ) + { + switch( m_eBuildSystem ) + { + case SBS_V1: + // Add first target modules name without extension to build cmd. + sCmd.append( " " ); + sCmd.append( RemovePathAndExt( m_vTargetModules.at( 0 ), true ) ); + break; + case SBS_V2: + // Add all target modules to build command using raptor switch '-p'. + for( size_t i = 0 ; i < m_vTargetModules.size() ; i++ ) + { + LOG_STRING("Adding :" << m_vTargetModules.at( i ) ); + sCmd.append( " -p " ); + sCmd.append( m_vTargetModules.at( i ) ); + } + break; + } + } +} + +bool CATProject::IsTargetModuleInProject() const +{ + LOG_FUNC_ENTRY("CATProject::IsTargetModuleInProject"); + vector::const_iterator modules; + vector::const_iterator staticModules; + vector::const_iterator targets; + bool bRet = true; + // Do we have target modules defined + if ( m_vTargetModules.size() > 0 ) + { + // Sbs version 1 support only single target module. + if ( m_eBuildSystem == SBS_V1 ) + { + // Try to find module from project. + bRet = false; + string sTarget = m_vTargetModules.at(0); + for( modules = m_vModules.begin() ; modules != m_vModules.end() ; modules++ ) + { + if( (*modules)->GetMmpFile().find( sTarget ) != string::npos ) + { + // Found it return true. + bRet = true; + break; + } + } + for( staticModules = m_vStaticLibraries.begin(); staticModules != m_vStaticLibraries.end(); staticModules++ ) + { + if( (*staticModules)->GetMmpFile().find( sTarget ) != string::npos ) + { + bRet = true; + break; + } + } + if ( ! bRet ) + { + // Not found display error message. + cout << AT_MSG << "Error, " << sTarget << " not defined in project." << endl; + } + } + // Sbs version 2 supports multiple target modules. + else if ( m_eBuildSystem == SBS_V2 ) + { + // Check that all targets are defined in project. + for( targets = m_vTargetModules.begin(); targets != m_vTargetModules.end() ; targets++ ) + { + // Found iterated target? + bool bFound = false; + for ( modules = m_vModules.begin() ; modules != m_vModules.end() ; modules++ ) + { + if( (*modules)->GetMmpFile().find( *targets ) != string::npos ) + { + // yes. + bFound = true; + break; + } + } + for( staticModules = m_vStaticLibraries.begin(); staticModules != m_vStaticLibraries.end(); staticModules++ ) + { + if( (*staticModules)->GetMmpFile().find( *targets ) != string::npos ) + { + bFound = true; + break; + } + } + if ( ! bFound ) + { + // Display error when not found and set return value false. + bRet = false; + cout << AT_MSG << "Error, " << targets->c_str() << " not defined in project." << endl; + } + } + } + } + return bRet; +} + +string CATProject::GetBuildTypeString() +{ + LOG_LOW_FUNC_ENTRY("CATProject::GetBuildTypeString"); + // Return build type as lowercase string + switch( m_eBuildType ) + { + case UDEB: + return string("udeb"); + case UREL: + return string("urel"); + default: + return ""; + } +} + +string CATProject::GetBuildTypeString( int eType ) +{ + LOG_LOW_FUNC_ENTRY("CATProject::GetBuildTypeString( int eType )"); + // Return build type as lowercase string + switch( eType ) + { + case UDEB: + return string("udeb"); + case UREL: + return string("urel"); + default: + return string("unknown"); + } +} + +bool CATProject::CleanTemporaryDirs() +{ + LOG_FUNC_ENTRY("CATProject::CleanTemporaryDirs"); + bool bRet = true; + // Modules + for( size_t i = 0; i < m_vModules.size(); i++ ) + { + if ( ! m_vModules.at(i)->CleanTemporaryDir() ) + bRet = false; + } + for( size_t i = 0; i < m_vStaticLibraries.size(); i++ ) + { + if ( ! m_vStaticLibraries.at(i)->CleanTemporaryDir() ) + bRet = false; + } + // Projects + vector vFileList = DirList( AT_TEMP_DIR, false , true ); + vector::iterator it2 = vFileList.begin(); + // Size of constant table + int iCount = sizeof( TEMP_EXTENSION_NO_DELETE ) / sizeof( string ); + while ( it2 != vFileList.end() ) + { + // Get extension and compare it to list + bool bDelete = true; + string sExtension = GetExtension( *it2 ); + ChangeToLower( sExtension ); + for ( int i = 0 ; i < iCount ; i++ ) + { + if( sExtension.compare( TEMP_EXTENSION_NO_DELETE[i] ) == 0 ) + { + bDelete = false; + break; + } + } + if ( bDelete ) + { + // Delete file + if ( ! FileDelete( *it2, true ) ) + bRet = false; + } + // Increment + it2++; + } + return bRet; +} + +bool CATProject::DeleteTemporaryDirs() +{ + LOG_FUNC_ENTRY("CATProject::DeleteTemporaryDirs"); + bool bRet = true; + // Modules + for( size_t i = 0; i < m_vModules.size(); i++ ) + { + if (! m_vModules.at(i)->DeleteTemporaryDir() ) + bRet = false; + } + for( size_t i = 0; i < m_vStaticLibraries.size(); i++ ) + { + if (! m_vStaticLibraries.at(i)->DeleteTemporaryDir() ) + bRet = false; + } + return bRet; +} + +bool CATProject::InitSbs1MakeFileWithPathToTemp() +{ + LOG_FUNC_ENTRY("CATProject::InitSbs1MakeFileWithPathToTemp"); + // Use temporary folder + m_sMakeFile.clear(); + m_sMakeFile.append( AT_TEMP_DIR ); + m_sMakeFile.append( "\\" ); + m_sMakeFile.append( AT_LEVEL_1_MAKEFILE_NAME ); + // At end check does it exist, return the result. + return FileExists( m_sMakeFile.c_str() ); +} + +bool CATProject::InitSbs1MakeFileWithPath() +{ + LOG_FUNC_ENTRY("CATProject::InitMakeFileWithPath"); + if ( m_sEpocRoot.empty() ) + { + LOG_STRING("Error, epocroot is not set."); + return false; + } + m_sMakeFile.clear(); + m_sMakeFile.append( m_sEpocRoot ); + if( *m_sMakeFile.rbegin() != '\\' ) + m_sMakeFile.append( "\\" ); + m_sMakeFile.append( "epoc32\\build\\" ); + // Add current directory to path (first remove driveletter). + string sCurrentDir( m_cCurrentDir ); + if ( sCurrentDir.length() < 3 ) + { + LOG_STRING("Error, current dir invalid."); + return false; + } + sCurrentDir.erase(0,3); + m_sMakeFile.append( sCurrentDir ); + m_sMakeFile.append( "\\" ); + // Platform + string sPlatInUpper( m_sPlatform); + ChangeToUpper( sPlatInUpper ); + m_sMakeFile.append( sPlatInUpper ); + // Possible variant + if ( m_sVariant.empty() ) + { + // Test modules only? + if ( m_bAbldTest ) + m_sMakeFile.append( "TEST" ); + m_sMakeFile.append( "." ); + m_sMakeFile.append( "MAKE" ); + } + else + { + m_sMakeFile.append( "." ); + m_sMakeFile.append( m_sVariant ); + // Test modules only? + if ( m_bAbldTest ) + m_sMakeFile.append( "TEST" ); + m_sMakeFile.append( ".MAKE" ); + } + // At end check does it exist, return the result. + return FileExists( m_sMakeFile.c_str() ); +} + +// ---------------------------------------------------------------------------- +// Get & Sets +// ---------------------------------------------------------------------------- +void CATProject::SetBuildSystem( BUILD_SYSTEM eSystem ) +{ + LOG_FUNC_ENTRY("CATProject::SetBuildSystem"); + m_eBuildSystem = eSystem; +} +void CATProject::SetMode( PROJECT_MODE eMode ) +{ + LOG_FUNC_ENTRY("CATProject::SetMode"); + m_eMode = eMode; +} +int CATProject::GetMode() const +{ + LOG_LOW_FUNC_ENTRY("CATProject::GetMode"); + return m_eMode; +} +void CATProject::SetEpocRoot( const string& sEpocRoot ) +{ + LOG_FUNC_ENTRY("CATProject::SetEpocRoot"); + m_sEpocRoot = sEpocRoot; +} +void CATProject::SetPlatform( const string& sPlatform ) +{ + LOG_FUNC_ENTRY("CATProject::SetPlatform"); + m_sPlatform = sPlatform; +} +void CATProject::SetVariant( const string& sVariant ) +{ + LOG_FUNC_ENTRY("CATProject::SetVariant"); + m_sVariant = sVariant; +} +void CATProject::SetLoggingMode( LOGGING_MODE eLoggingMode) +{ + LOG_FUNC_ENTRY("CATProject::SetLoggingMode"); + m_eLoggingMode = eLoggingMode; +} +void CATProject::SetAllocCallStackSize( int iAllocCallStackSize ) +{ + m_iAllocCallStackSize = iAllocCallStackSize; +} +void CATProject::SetFreeCallStackSize( int iFreeCallStackSize ) +{ + m_iFreeCallStackSize = iFreeCallStackSize; +} +void CATProject::SetBuildType( BUILD_TYPE eType ) +{ + LOG_FUNC_ENTRY("CATProject::SetBuildType"); + m_eBuildType = eType; +} +void CATProject::SetS60FileName( const string& sFileName) +{ + LOG_FUNC_ENTRY("CATProject::SetS60FileName"); + m_sS60FileName = sFileName; +} +void CATProject::SetRomSymbolFiles(const vector& vRomSymbolFiles) +{ + LOG_FUNC_ENTRY("CATProject::SetRomSymbolFiles"); + m_vRomSymbolFiles = vRomSymbolFiles; +} +void CATProject::SetTargetModule(const string& sTargetModule) +{ + LOG_FUNC_ENTRY("CATProject::SetTargetModule"); + m_sTargetModule = sTargetModule; + ChangeToLower( m_sTargetModule); +} +void CATProject::SetBinaryTarget(const string& sBinaryTarget) +{ + LOG_FUNC_ENTRY("CATProject::SetBinaryTarget"); + m_sBinaryTarget = sBinaryTarget; + ChangeToLower( m_sBinaryTarget ); +} +void CATProject::SetDataFile( const string& sDataFile ) +{ + LOG_FUNC_ENTRY("CATProject::SetDataFile"); + m_sDataFile = sDataFile; +} +void CATProject::SetLogLevel( int iLogLevel ) +{ + LOG_FUNC_ENTRY("CATProject::SetLogLevel"); + m_iLoggingLevel = iLogLevel; +} +void CATProject::SetDataFileOutput( const string& sDataFileOutput ) +{ + LOG_FUNC_ENTRY("CATProject::SetDataFileOutput"); + m_sDataFileOutput = sDataFileOutput; +} +void CATProject::SetTargetModules( const vector& vTargetModules ) +{ + LOG_FUNC_ENTRY("CATProject::SetTargetModules"); + m_vTargetModules = vTargetModules; +} +void CATProject::SetBuildCommand( const string& sBuildCommand ) +{ + LOG_FUNC_ENTRY("CATProject::SetBuildCommand"); + m_sBuildCommand = sBuildCommand; +} +// End of file diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/src/arguments.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/src/arguments.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,798 @@ +/* +* 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: Argument parsing functions. +*/ +#include "../inc/ATCommonDefines.h" +#include "../inc/CATBase.h" + +//Forward declarations. +bool parseBaseArguments( vector& vArgs, ARGUMENTS& args ); +bool parseHookArguments( vector& vArgs, ARGUMENTS& args ); +bool parseAnalyzeArguments( vector& vArgs, ARGUMENTS& args ); +bool parseParseArguments( vector& vArgs, ARGUMENTS& args ); +bool checkDataFileName( string& sFileName ); +bool parseSbsConfiguration( string& sConfiguration, ARGUMENTS& args ); + +// Constants for old "hooking" parameter parsing. +#define INVALID_PARAMETER "AnalyzeTool : Error, invalid parameter: " +const char DATAFILENAME_INVALID_CHARS[] = " &^+-@$%*()|\\/[]{}<>?;:,\"'"; + +/** +* Check datafile name for invalid characters. +* @return true if file name ok. +*/ +bool checkDataFileName( string& sFileName ) +{ + for ( size_t i = 0; i < sFileName.length(); i++ ) + { + const char c = sFileName.at( i ); + if( strchr( DATAFILENAME_INVALID_CHARS, c ) != 0 ) + return false; + } + return true; +} + +/** +* Parse base arguments from given vector of strings. +* Removes debug / help arguments from vector. +*/ +bool parseBaseArguments( vector& vArgs, ARGUMENTS& args ) +{ + // Iterator used in this function. + vector::iterator it; + // If no arguments set show help true. + if ( vArgs.size() == 0 ) + { + args.eMainSwitch = SWITCH_UNKNOWN; + args.bHelp = true; + } + //Try find help and debug switches. + //Note: -help is main switch what shows syntax examples. + for(it = vArgs.begin(); it != vArgs.end(); it++ ) + { + //Help switches. + if ( ! _stricmp( (*it).c_str(), "-?" ) ) + { + args.bHelp = true; + it = vArgs.erase( it ); + if ( it == vArgs.end() ) + break; + } + else if ( ! _stricmp( (*it).c_str(), "--?" ) ) + { + args.bHelp = true; + it = vArgs.erase( it ); + if ( it == vArgs.end() ) + break; + } + else if ( ! _stricmp( (*it).c_str(), "--help" ) ) + { + args.bHelp = true; + it = vArgs.erase( it ); + if ( it == vArgs.end() ) + break; + } + else if ( ! _stricmp( (*it).c_str(), "/?" ) ) + { + args.bHelp = true; + it = vArgs.erase( it ); + if ( it == vArgs.end() ) + break; + } + //Debug switches. + else if ( ! _stricmp( (*it).c_str(), "-show_debug" ) ) + { + args.bDebugConsole = true; + it = vArgs.erase( it ); + if ( it == vArgs.end() ) + break; + } + else if ( ! _stricmp( (*it).c_str(), "--show_debug" ) ) + { + args.bDebugConsole = true; + it = vArgs.erase( it ); + if ( it == vArgs.end() ) + break; + } + else if ( ! _stricmp( (*it).c_str(), "-show_debug_all" ) ) + { + args.bDebugConsole = true; + args.bDebugLowLevel = true; + it = vArgs.erase( it ); + if ( it == vArgs.end() ) + break; + } + else if ( ! _stricmp( (*it).c_str(), "--show_debug_all" ) ) + { + args.bDebugConsole = true; + args.bDebugLowLevel = true; + it = vArgs.erase( it ); + if ( it == vArgs.end() ) + break; + } + else if ( ! _stricmp( (*it).c_str(), "-show_dbgview" ) ) + { + args.bDebugDbgView = true; + it = vArgs.erase( it ); + if ( it == vArgs.end() ) + break; + } + else if ( ! _stricmp( (*it).c_str(), "--show_dbgview" ) ) + { + args.bDebugDbgView = true; + it = vArgs.erase( it ); + if ( it == vArgs.end() ) + break; + } + else if ( ! _stricmp( (*it).c_str(), "-show_dbgview_all" ) ) + { + args.bDebugDbgView = true; + args.bDebugLowLevel = true; + it = vArgs.erase( it ); + if ( it == vArgs.end() ) + break; + } + else if ( ! _stricmp( (*it).c_str(), "--show_dbgview_all" ) ) + { + args.bDebugDbgView = true; + args.bDebugLowLevel = true; + it = vArgs.erase( it ); + if ( it == vArgs.end() ) + break; + } + //Raptor switch. + else if ( ! _stricmp( (*it).c_str(), "-sbs2" ) ) + { + args.bEnableSbs2 = true; + it = vArgs.erase( it ); + if ( it == vArgs.end() ) + break; + } + } + if ( vArgs.size() > 0 ) + { + //Pick up main switch. + it = vArgs.begin(); + if ( ! _stricmp( (*it).c_str(), "-a" ) ) + args.eMainSwitch = SWITCH_ANALYZE; + else if ( ! _stricmp( (*it).c_str(), "-p" ) ) + args.eMainSwitch = SWITCH_PARSE_TRACE; + else if ( ! _stricmp( (*it).c_str(), "-c" ) ) + args.eMainSwitch = SWITCH_CLEAN; + else if ( ! _stricmp( (*it).c_str(), "-v" ) ) + args.eMainSwitch = SWITCH_VERSION; + else if ( ! _stricmp( (*it).c_str(), "-vdbghelp" ) ) + args.eMainSwitch = SWITCH_DBGHELP_VERSION; + else if ( ! _stricmp( (*it).c_str(), "-help" ) ) + args.eMainSwitch = SWITCH_HELP; + else if ( ! _stricmp( (*it).c_str(), "-me" ) ) + { + args.eMainSwitch = SWITCH_HOOK; + args.eHookSwitch = HOOK_EXTERNAL; + } + else if ( ! _stricmp( (*it).c_str(), "-e" ) ) + { + args.eMainSwitch = SWITCH_HOOK; + args.eHookSwitch = HOOK_EXTERNAL_FAST; + } + else if ( ! _stricmp( (*it).c_str(), "-mi" ) ) + { + args.eMainSwitch = SWITCH_HOOK; + args.eHookSwitch = HOOK_INTERNAL; + } + else if ( ! _stricmp( (*it).c_str(), "-instrument_i" ) ) + { + args.eMainSwitch = SWITCH_HOOK; + args.eHookSwitch = HOOK_EXTENSION_INTERNAL; + } + else if ( ! _stricmp( (*it).c_str(), "-instrument_e" ) ) + { + args.eMainSwitch = SWITCH_HOOK; + args.eHookSwitch = HOOK_EXTENSION_EXTERNAL; + } + else if ( ! _stricmp( (*it).c_str(), "-instrument_ef" ) ) + { + args.eMainSwitch = SWITCH_HOOK; + args.eHookSwitch = HOOK_EXTENSION_EXTERNAL_FAST; + } + else if ( ! _stricmp( (*it).c_str(), "-uninstrument" ) ) + { + args.eMainSwitch = SWITCH_UNHOOK; + args.eHookSwitch = HOOK_EXTENSION_UNINSTRUMENT; + } + else if ( ! _stricmp( (*it).c_str(), "-uninstrument_failed" ) ) + { + args.eMainSwitch = SWITCH_UNHOOK; + args.eHookSwitch = HOOK_EXTENSION_FAILED; + } + } + return true; +} + +/** +* Parse analyze related arguments from given vector of strings. +*/ +bool parseAnalyzeArguments( vector& vArgs, ARGUMENTS& args ) +{ + bool bRet = true; + if ( vArgs.size() < 2 ) + { + cout << AT_MSG << "Error, missing datafile." << endl; + return false; + } + // Iterator used in this function. + vector::const_iterator it; + for(it = vArgs.begin()+1; it != vArgs.end(); it++ ) + { + if ( it->find("-l") != string::npos ) + { + if ( it->length() == 3 ) + { + // Create char array for atoi function + char level[2]; + level[0] = it->at(2); + level[1] = 0; // null terminate + // check that its digit first + if ( isdigit(level[0]) ) + { + // pass array to atoi + int iLoggingLevel = atoi( level ); + if ( iLoggingLevel >= 0 && iLoggingLevel <= 3 ) + { + // log level ok + args.ANALYZE.iLoggingLevel = iLoggingLevel; + continue; + } + } + bRet = false; + cout << AT_MSG << "Invalid logging level specified (0-3)." << endl; + args.ANALYZE.iLoggingLevel = -1; + } + } + // No else here because logging level check is done to all args in list. + // Rom symbol file + if( _stricmp( it->c_str(), "-s" ) == 0 ) + { + it++; + if ( it == vArgs.end() ) + { + bRet = false; + cout << AT_MSG << "Missing symbol file." << endl; + break; // Leave for loop. + } + else + { + args.ANALYZE.bSymbolFile = true; + args.ANALYZE.vSymbolFiles.push_back( *it ); + continue; + } + } + else + { + // If we got datafile we must assume this is output + if( ! args.ANALYZE.sDataFile.empty() ) + { + if ( args.ANALYZE.sOutputFile.empty() ) + args.ANALYZE.sOutputFile = *it; + else + { + bRet = false; + cout << AT_MSG << "Invalid parameter: " << *it << endl; + } + } + // If this is file we assume datafile + else if( CATBase::FileExists( it->c_str() ) ) + { + args.ANALYZE.sDataFile = *it; + } + else + { + bRet = false; + cout << AT_MSG << "Specified datafile does not exist." << endl; + } + } + } + if ( args.ANALYZE.sDataFile.empty() ) + bRet = false; + return bRet; +} + + +/** +* Parse hooking related arguments from given vector of strings. +*/ +bool parseHookArguments( vector& vArgs, ARGUMENTS& args ) +{ + bool bRet = true; + try { + // Iterator used in this function. + vector::const_iterator it; + + // Check that we have some arguments except main switch. + if ( vArgs.size() < 2 ) + { + if ( args.eHookSwitch == HOOK_EXTENSION_UNINSTRUMENT + || args.eHookSwitch == HOOK_EXTENSION_FAILED + ) + return bRet; + cout << AT_MSG << "Error, Missing build command." << endl; + bRet = false; + } + bool bBuildFound = false; + for(it = vArgs.begin()+1; it != vArgs.end(); it++ ) + { + // If's to pickup atool options + // no build switch + if ( _stricmp( it->c_str(), "-nobuild" ) == 0 ) + { + args.HOOK.bNoBuild = true; + } + // call stack size(s) + else if ( _stricmp( it->c_str(), "-acs" ) == 0 || _stricmp( it->c_str(), "-fcs" ) == 0 ) + { + // Free vs Alloc + bool bAlloc = true; + if ( _stricmp( it->c_str(), "-fcs" ) == 0 ) + bAlloc = false; + // Value + it++; + if ( it== vArgs.end() ) + { + bRet = false; + cout << AT_MSG << "Error, missing call stack size parameter." << endl; + break; + } + else if ( ! _stricmp( it->c_str(), "sbs" ) + || ! _stricmp( it->c_str(), "abld" ) + || ! _stricmp( it->c_str(), "-f" ) ) + { + bRet = false; + cout << AT_MSG << "Error, missing call stack size parameter." << endl; + break; + } + else + { + int i; + // Try to parse integer value using stream. + istringstream ss( *it ); + if ( ss>>i ) + { + // Value parsed ok now check bounds. + if ( i < AT_CALL_STACK_SIZE_MIN ) + { + bRet = false; + cout << AT_MSG << "Error, specified call stack size value too small." << endl; + break; + } + else if ( i > AT_CALL_STACK_SIZE_MAX ) + { + bRet = false; + cout << AT_MSG << "Error, specified call stack size value too big." << endl; + break; + } + else + { + // Value valid. + if ( bAlloc ) + args.HOOK.iAllocCallStackSize = i; + else + args.HOOK.iFreeCallStackSize = i; + } + } + else + { + // Error parsing value using stream. + bRet = false; + cout << AT_MSG << "Error, specified call stack size value invalid." << endl; + break; + } + + } + } + // Data file name. + else if ( _stricmp( it->c_str(), "-f" ) == 0 ) + { + it++; + if ( it == vArgs.end() ) + { + bRet = false; + cout << AT_MSG << "Error, missing internal data gathering file name." << endl; + break; + } + else if ( ! _stricmp( it->c_str(), "sbs" ) || ! _stricmp( it->c_str(), "abld" ) ) + { + bRet = false; + cout << AT_MSG << "Error, missing internal data gathering file name." << endl; + break; + } + else + { + if ( checkDataFileName( string( *it ) ) ) + { + // Pickup filename. + args.HOOK.bDataFileName = true; + args.HOOK.sDataFileName = *it; + } + else + { + bRet = false; + cout << AT_MSG << "Error, specified internal data gathering file name contains invalid character(s)." << endl; + break; + } + } + } + // Build command parsing. + else if ( _stricmp( it->c_str(), "sbs" ) == 0 ) + { + // By default sbs command is not valid. + bRet = false; + // By default build found + bBuildFound = true; + // Use raptor build system, pickup all rest arguments to sbs commmand. + bool bFoundConfig = false; // Is configuration defined. + args.HOOK.iBuildSystem = 2; + vector::const_iterator itC = it; + args.HOOK.sBuildCmd.clear(); + for ( ; itC != vArgs.end() ; itC++ ) + { + args.HOOK.sBuildCmd.append( *itC ); + args.HOOK.sBuildCmd.append( " " ); + args.HOOK.vBuildCmd.push_back( *itC ); + } + // Remove last space + if ( args.HOOK.vBuildCmd.size() > 1 ) + args.HOOK.sBuildCmd.erase( args.HOOK.sBuildCmd.size()-1 ); + + // Parse needed variables from sbs command. + vector::iterator itSbs; + for( itSbs = args.HOOK.vBuildCmd.begin(); itSbs != args.HOOK.vBuildCmd.end() ; itSbs++ ) + { + // Program(s). + if ( _stricmp( itSbs->c_str(), "-p" ) == 0 ) + { + // Next is program. + itSbs++; + args.HOOK.vTargetPrograms.push_back( *itSbs ); + } + else if ( itSbs->find( "--project=" ) != string::npos ) + { + itSbs->erase(0, 10 ); + args.HOOK.vTargetPrograms.push_back( *itSbs ); + } + // platform & build type ( configuration ) + else if ( _stricmp( itSbs->c_str(), "-c" ) == 0 || itSbs->find( "--config=" ) != string::npos ) + { + // Error message if config found more than once. + if ( bFoundConfig ) + { + cout << AT_MSG << "Error, no support defining more than one configuration." << endl; + bRet = false; + continue; + } + + if (_stricmp( itSbs->c_str(), "-c" ) == 0 ) + { + // Next is the configuration + itSbs++; + // Check that iterator is valid. + if ( itSbs == args.HOOK.vBuildCmd.end() ) + break; + } + else + { + // Remove the "--config=". + itSbs->erase( 0, 9 ); + // Check its not empty. + if ( itSbs->size() == 0 ) + break; + } + + // Identify configuration, if successful set sbs command as valid. + if ( parseSbsConfiguration( *itSbs, args ) ) + bRet = true; + // Set we encountered one configuration. + bFoundConfig = true; + } + } + // Error message if command is missing configuration. + if ( !bFoundConfig ) + cout << AT_MSG << "Error, missing configuration definition from sbs cmd." << endl; + } + else if ( _stricmp( it->c_str(), "abld" ) == 0 ) + { + bBuildFound = true; + // Use abld build system, pickup all rest argumenst as abld options. + args.HOOK.iBuildSystem = 1; + + vector::const_iterator itC = it; + args.HOOK.sBuildCmd.clear(); + for ( ; itC != vArgs.end() ; itC++ ) + { + args.HOOK.sBuildCmd.append( *itC ); + args.HOOK.sBuildCmd.append( " " ); + args.HOOK.vBuildCmd.push_back( *itC ); + } + + string sCmd( args.HOOK.sBuildCmd ); // build command to lower case here. + for( size_t i = 0 ; i < sCmd.size(); i++ ) + sCmd.at(i) = tolower( sCmd.at(i) ); + + // Remove all until platform + if ( sCmd.find("build ") != string::npos ) + { + // Check is test defined + if ( sCmd.substr(0, sCmd.find("build ")).find("test") != string::npos ) + args.HOOK.bAbldTest = true; + sCmd.erase( 0, sCmd.find("build")+6 ); + } + else + return false; + + //Is -debug switch in command? + if( sCmd.find( "-debug " ) != string::npos ) + { + sCmd.erase( sCmd.find( "-debug " ), 7 ); + } + + // Parse needed "variables" from command. + bool bOk = false; + + // Find platform + if ( sCmd.find( "armv5" ) != string::npos ) + { + bOk = true; + args.HOOK.sPlatform = "armv5"; + sCmd.erase( sCmd.find( "armv5" ), 5 ); + } + else if ( sCmd.find( "winscw" ) != string::npos ) + { + bOk = true; + args.HOOK.sPlatform = "winscw"; + sCmd.erase( sCmd.find( "winscw" ), 6 ); + } + else if ( sCmd.find( "gcce" ) != string::npos ) + { + bOk = true; + args.HOOK.sPlatform = "gcce"; + sCmd.erase( sCmd.find( "gcce" ), 4 ); + } + if ( bOk ) + { + // Feature variant. + if ( sCmd.at(0 ) == '.' ) + { + sCmd.erase(0,1); + args.HOOK.sFeatureVariant = sCmd.substr( 0, sCmd.find_first_of(' ') ); + sCmd.erase(0, sCmd.find_first_of(' ')+1 ); + } + } + else + { + // not platform specified. + cout << AT_MSG << "Error, no supported platform found in abld parameters (armv5/winscw/gcce)." << endl; + bRet = false; + } + + // find build type + bOk = false; + if ( sCmd.find( "urel" ) != string::npos ) + { + bOk = true; + args.HOOK.sBuildType = "urel"; + sCmd.erase( sCmd.find( "urel" ), 4 ); + } + + else if ( sCmd.find( "udeb" ) != string::npos ) + { + bOk = true; + args.HOOK.sBuildType = "udeb"; + sCmd.erase( sCmd.find( "udeb" ), 4 ); + } + if( !bOk ) + { + // no build type specified. + cout << AT_MSG << "Error, no build type specified in abld parameters (udeb/urel)." << endl; + bRet = false; + } + + // Is there multiple programs (only should be used from extension). + if ( sCmd.find(" -p") != string::npos ) + { + sCmd.erase( sCmd.find(" -p" ), sCmd.size() - sCmd.find(" -p" ) ); + // Loop thru all parameters and pick up programs. + vector::iterator it; + for( it = args.HOOK.vBuildCmd.begin(); it != args.HOOK.vBuildCmd.end(); it++ ) + { + if ( _stricmp( it->c_str(), "-p" ) == 0 ) + { + // Next is program. + it++; + string sProgram = *it; + // Make sure program name ends with ".mmp". + CATBase::ChangeToLower( sProgram ); + if ( sProgram.length() >= 4 ) + { + string sEnd = sProgram.substr( sProgram.length()-4, 4 ); + if ( sEnd.compare( ".mmp" ) != 0 ) + sProgram.append( ".mmp" ); + } + else + sProgram.append( ".mmp" ); + args.HOOK.vTargetPrograms.push_back( sProgram ); + } + } + } + else { + // find single defined program. + if ( sCmd.find_first_not_of(' ') != string::npos ) + { + size_t iS = sCmd.find_first_not_of(' '); + size_t iE = sCmd.find_first_of(' ', iS ); + string sProgram; + if ( iE == string::npos ) + sProgram = sCmd.substr( iS, sCmd.size()-iS ); + else + sProgram = sCmd.substr( iS, iE-iS); + // Make sure program name ends with ".mmp". + CATBase::ChangeToLower( sProgram ); + if ( sProgram.length() >= 4 ) + { + string sEnd = sProgram.substr( sProgram.length()-4, 4 ); + if ( sEnd.compare( ".mmp" ) != 0 ) + sProgram.append( ".mmp" ); + } + else + sProgram.append( ".mmp" ); + args.HOOK.vTargetPrograms.push_back( sProgram ); + } + } + } + else + { + if ( ! bBuildFound ) + { + bRet = false; + cout << AT_MSG << "Error, invalid parameter :" << *it << endl; + break; + } + } + } + } + catch(...) + { + bRet = false; + cout << AT_MSG << "Error parsing arguments." << endl; + } + return bRet; +} + + +/** +* Parse trace parsing related arguments from given vector of strings. +*/ +bool parseParseArguments( vector& vArgs, ARGUMENTS& args ) +{ + // Iterator used in this function. + vector::const_iterator it = vArgs.begin(); + + if ( it == vArgs.end() ) + return false; + + it++; + + if ( it == vArgs.end() ) + { + cout << AT_MSG << "Error, input file not defined (raw data file)." << endl; + return false; + } + + //Input. + args.PARSE.bDataFile = true; + args.PARSE.sDataFile = *it; + + it++; + if ( it == vArgs.end() ) + { + + cout << AT_MSG << "Error, output file not defined (device data file)." << endl; + return false; + } + + //Output. + args.PARSE.bOutputFile = true; + args.PARSE.sOutputFile = *it; + return true; +} + +/** +* Identifies/parses the configuration string when raptor used (-c / --config= ). +*/ +bool parseSbsConfiguration( string& sConfiguration, ARGUMENTS& args ) +{ + CATBase::ChangeToLower( sConfiguration ); + vector tokens = CATBase::ParseStringToVector( sConfiguration, '.' ); + + //we check if winscw/armv5 and udeb/urel is used + //rest of the "." are variants which we all support by default. + + //first we check if some of aliases is used + if ( tokens.at(0).compare("armv5_urel") == 0 ) + { + args.HOOK.sPlatform = "armv5"; + args.HOOK.sBuildType = "urel"; + return true; + } + else if ( tokens.at(0).compare("armv5_udeb") == 0 ) + { + args.HOOK.sPlatform = "armv5"; + args.HOOK.sBuildType = "udeb"; + return true; + } + else if ( tokens.at(0).compare("winscw_udeb") == 0) + { + args.HOOK.sPlatform = "winscw"; + args.HOOK.sBuildType = "udeb"; + return true; + } + else if ( tokens.at(0).compare("winscw_urel") == 0 ) + { + args.HOOK.sPlatform = "winscw"; + args.HOOK.sBuildType = "urel"; + return true; + } + //if 1st token is not an alias, lets try dot configurations + else if ( tokens.at(0).compare("arm") == 0 ) + { + // check we have atleast 3 tokens. i.e arm v5 debug x ... + if ( tokens.size() >= 3 ) + { + // Next configuration is arm version, we only support v5. + if ( tokens.at(1).compare( "v5" ) == 0) + { + args.HOOK.sPlatform = "armv5"; + + // Check next configuration part is debug or release + if ( tokens.at(2).compare( "udeb" ) == 0) + { + args.HOOK.sBuildType = "udeb"; + return true; + } + else if ( tokens.at(2).compare( "urel" ) == 0 ) + { + args.HOOK.sBuildType = "urel"; + return true; + } + else + { + cout << AT_MSG << "Error in sbs configuration part: " << tokens.at(2) << endl; + cout << AT_MSG << "Supported are: udeb,urel." << endl; + return false; + } + } + else + { + cout << AT_MSG << "Error in sbs configuration part: " << tokens.at(1) << endl; + cout << AT_MSG << "Supported are: v5." << endl; + return false; + } + } + } + + cout << AT_MSG << "Error in sbs configuration part: " << tokens.at(0) << endl; + cout << AT_MSG << "Supported are: arm, armv5_urel, armv5_udeb, winscw_udeb, winscw_urel." << endl; + return false; + +} + +//EOF diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/src/atool.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/src/atool.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,236 @@ +/* +* 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: Defines the entry point for the console application. +* +*/ + +// Includes. +#include "../inc/ATCommonDefines.h" +#include "../inc/CATDatParser.h" +#include "../inc/CATParseTraceFile.h" +#include "../inc/CATProject.h" + +//Debug logging parameters +//To enable debugging as argument to atool.exe use: +//--show_debug / -show_debug : Normal logging in console. +//--show_debug_all / -show_debug_all : Log all (low level functions also) to console. +//--show_dbgview / -show_dbgview : Normal logging to windows debug messages. +//--show_dbgview_all / -show_dbgview_all : Log all (low level functions also) to windows debug messages. + +//Return codes (errorlevel) defined in AT_RETURN_CODE structure see ATCommonDefines.h. + +extern bool g_bDebugConsole = false; +extern bool g_bDebugDbgView = false; +extern bool g_bDebugLowLevel = false; + +//Argument parsing. +extern bool parseBaseArguments( vector& vArgs, ARGUMENTS& args ); +extern bool parseHookArguments( vector& vArgs, ARGUMENTS& args ); +extern bool parseAnalyzeArguments( vector& vArgs, ARGUMENTS& args ); +extern bool parseParseArguments( vector& vArgs, ARGUMENTS& args ); + +//Helps. +extern void print_help( void ); +extern void print_syntax_examples( void ); + +//AT Library check functions +extern bool CheckATLibrariesArmv5( string sEpocRoot ); +extern bool CheckATLibrariesArmv5Abiv2( string sEpocRoot ); +extern bool CheckATLibrariesWinscw( string sEpocRoot ); + +//CLE version functions. +extern int showVersionInfo( void ); + +//dbghelp.dll version function. +extern int showDbgHelpVersionInfo( bool showVersion ); + +//Miscelllanaeous functions. +extern bool CheckSBS2Folder( void ); + +const char DEBUG_PARAMETER_CONSOLE[] = "-debug"; +const char DEBUG_PARAMETER_DBGVIEW[] = "-dbgview"; +const char SBS2_PARAMETER[] = "-sbs2"; +char g_cCurrentDir[MAX_LINE_LENGTH]; + +//Global compile class objects are neededif ctrl+c is pressed mmp file must be restored. +CATProject project_module; + +//Parse object. +CATParseTraceFile Parser; + +/** +* Handle process control signals. +*/ +BOOL WINAPI HandlerRoutine( DWORD dwCtrlType ) +{ + //Run recovery and exit for project if user presses ctrl+c + //or close signal is received. + if( dwCtrlType == CTRL_C_EVENT || dwCtrlType == CTRL_CLOSE_EVENT ) + { + int iMode = project_module.GetMode(); + if ( iMode == CATProject::COMPILE + || iMode == CATProject::INSTRUMENT + || iMode == CATProject::INSTRUMENT_CONSOLE ) + project_module.RunRecoveryAndExit(); + } + //Return false so program execution is stopped. + return false; +} +// TESTING +int _tmain( int argc, _TCHAR* argv[] ) +{ + #ifdef MEM_LEAK_CHECK + _CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF ); + #endif + try { + //Set function to handle process control signals. + SetConsoleCtrlHandler( HandlerRoutine, true ); + vector vArguments; + for( int i = 1 ; i < argc ; i++ ) + { + vArguments.push_back( argv[i] ); + } + //Help variables. + string sEpocRoot(""); + //Parse base arguments. + ARGUMENTS args; + parseBaseArguments( vArguments, args ); + + // Debugging messages. + if ( args.bDebugConsole == true ) + g_bDebugConsole = true; + if ( args.bDebugDbgView == true ) + g_bDebugDbgView = true; + if ( args.bDebugLowLevel == true ) + g_bDebugLowLevel = true; + + //According to main switch parse rest arguments. + switch( args.eMainSwitch ) + { + case SWITCH_UNKNOWN: + print_help(); + return AT_RETURN_CODE::INVALID_ARGUMENT_ERROR; + case SWITCH_ANALYZE: + if ( ! parseAnalyzeArguments( vArguments, args ) ) + return AT_RETURN_CODE::INVALID_ARGUMENT_ERROR; + // Get epocroot + if( ! CATBase::GetEpocRoot( sEpocRoot ) ) + return AT_RETURN_CODE::CANNOT_FIND_EPOCROOT; + project_module.SetEpocRoot( sEpocRoot ); + // project not uninstrumented run it first. + if ( ! project_module.IsUninstrumented() ) + { + project_module.SetMode( CATProject::UNINSTRUMENT_CONSOLE ); + project_module.Run(); + } + // Set mode. + project_module.SetMode( CATProject::ANALYZE ); + project_module.SetLogLevel( args.ANALYZE.iLoggingLevel ); + project_module.SetDataFile( args.ANALYZE.sDataFile ); + if ( args.ANALYZE.bSymbolFile ) + project_module.SetRomSymbolFiles( args.ANALYZE.vSymbolFiles ); + project_module.SetDataFileOutput( args.ANALYZE.sOutputFile); + return project_module.Run(); + case SWITCH_HOOK: + // Parse arguments related to hooking. + if ( ! parseHookArguments( vArguments, args ) ) + return AT_RETURN_CODE::INVALID_ARGUMENT_ERROR; + // Set variables for project. + if ( ! project_module.SetArguments( args ) ) + return AT_RETURN_CODE::INVALID_ARGUMENT_ERROR; + // Get epocroot + if( ! CATBase::GetEpocRoot( sEpocRoot ) ) + return AT_RETURN_CODE::CANNOT_FIND_EPOCROOT; + project_module.SetEpocRoot( sEpocRoot ); + // Check AnalyzeTool libraries + if ( _stricmp( args.HOOK.sPlatform.c_str(), "winscw") == 0 ) + { + // Emulator winscw platform + if ( ! CheckATLibrariesWinscw(sEpocRoot) ) + return AT_RETURN_CODE::AT_LIBS_MISSING; + } + else + { + // Armv5 + if ( args.HOOK.iBuildSystem == 2 ) + { + // Abiv2 + if ( ! CheckATLibrariesArmv5Abiv2(sEpocRoot) ) + return AT_RETURN_CODE::AT_LIBS_MISSING; + } + else + { + // Abiv1 + if( ! CheckATLibrariesArmv5(sEpocRoot) ) + return AT_RETURN_CODE::AT_LIBS_MISSING; + } + } + // Run hooking. + return project_module.Run(); + //Uninstrument + case SWITCH_UNHOOK: + // Set variables for project. + if ( ! project_module.SetArguments( args ) ) + return AT_RETURN_CODE::INVALID_ARGUMENT_ERROR; + // Get epocroot + if( ! CATBase::GetEpocRoot( sEpocRoot ) ) + return AT_RETURN_CODE::CANNOT_FIND_EPOCROOT; + project_module.SetEpocRoot( sEpocRoot ); + return project_module.Run(); + case SWITCH_VERSION: + return showVersionInfo(); + case SWITCH_DBGHELP_VERSION: + return showDbgHelpVersionInfo( true ); + case SWITCH_CLEAN: + project_module.SetMode( CATProject::CLEAN ); + if ( CheckSBS2Folder() ) + project_module.SetBuildSystem( CATProject::SBS_V2 ); + else + project_module.SetBuildSystem( CATProject::SBS_V1 ); + return project_module.Run(); + case SWITCH_PARSE_TRACE: + if ( ! parseParseArguments( vArguments, args ) ) + return AT_RETURN_CODE::INVALID_ARGUMENT_ERROR; + if ( CATBase::IsDataFile( args.PARSE.sDataFile ) ) + { + cout << AT_MSG << "Error, " << args.PARSE.sDataFile << " is already parsed." << endl; + return AT_RETURN_CODE::INVALID_ARGUMENT_ERROR; + } + if ( args.PARSE.bOutputFile ) + { + //Save data with name in arguments[3] + Parser.StartParse( args.PARSE.sDataFile.c_str(), args.PARSE.sOutputFile.c_str() ); + } + else + { + Parser.StartParse( args.PARSE.sDataFile.c_str(), NULL ); + } + return AT_RETURN_CODE::OK; + case SWITCH_HELP: + print_help(); + print_syntax_examples(); + return AT_RETURN_CODE::OK; + default: + cout << AT_MSG << "Invalid parameters." << endl; + return AT_RETURN_CODE::INVALID_ARGUMENT_ERROR; + } + + } catch(...) + { + cout << AT_MSG << "Error, unhandled exception." << endl; + return AT_RETURN_CODE::UNHANDLED_EXCEPTION; + } +} + +//EOF diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/src/cataddr2line.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/src/cataddr2line.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,388 @@ +/* +* 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: Main module for addr2line pinpointing. +* +*/ + +#include "../inc/cataddr2line.h" +#include "../inc/CATMemoryAddress.h" +#include "../inc/CATBase.h" +#include "../inc/CATDatParser.h" + +#define ASCII_CHAR_CARRIAGE_RETURN 0x0D + +CATAddr2line::CATAddr2line() +{ + LOG_FUNC_ENTRY("CATAddr2line::CATAddr2line"); +} + +bool CATAddr2line::Open( const string& sParameter, const unsigned long /* iLong */ ) +{ + LOG_FUNC_ENTRY("CATAddr2line::Open"); + //Debugging for addr2line task. + //debug.open( "addr2line-lines.txt", ios_base::trunc ); + + m_sMapFileName.clear(); + // Add .map extendsion + m_sMapFileName.append( sParameter ); + m_sMapFileName.append( ".map" ); + + ReadMapFileArmv5(); + + //Make symfile path+name + string sFullPathToSymFile(sParameter); + sFullPathToSymFile.erase( sFullPathToSymFile.find_last_of( "." ), string::npos ); + sFullPathToSymFile.append( ".sym" ); + + // Check with extension + .sym also. + if ( ! CATBase::FileExists( sFullPathToSymFile.c_str() ) ) + { + sFullPathToSymFile.clear(); + sFullPathToSymFile.append( sParameter ); + sFullPathToSymFile.append( ".sym" ); + } + + return server.Initialize( sFullPathToSymFile ); +} + +string CATAddr2line::GetError( void ) +{ + LOG_FUNC_ENTRY("CATAddr2line::GetError"); + string s; + return s; +} + +bool CATAddr2line::Close( void ) +{ + LOG_FUNC_ENTRY("CATAddr2line::Close"); + //Debugging for addr2line task. + //debug.close(); + return true; +} + +bool CATAddr2line::AddressToLine( CATMemoryAddress* result ) +{ + LOG_FUNC_ENTRY("CATAddr2line::AddressToLine"); + + result->SetAddressToLineState( CATMemoryAddress::OUT_OF_RANGE); + + if( !server.GetProcessCreatedState() ) + return false; + //Count address + ULONG uStartA = result->GetModuleStartAddress(); + ULONG uMemoryA = result->GetAddress(); + ULONG uCountedA = uMemoryA - uStartA; + uCountedA += FUNCTIONS_OFFSET_IN_GCCE; + + string sTemp = CATBase::NumberToHexString( uCountedA ); + //Remove "0x" + size_t iCounter = sTemp.find_first_of('x'); + if( iCounter != string::npos ) + { + sTemp.erase( 0, (int)iCounter+1 ); + } + // Write to pipe that is the standard input for a child process. + server.WriteToPipe( sTemp ); + + // Read from pipe that is the standard output for child process. + string s = server.ReadFromPipe(); + + //If output not empty, parse output + if( !s.empty() ) + { + //Debugging code for addr2line task. + //debug.write( "##########\n", 12 ); + //debug.write( s.c_str(), s.size() ); + result->SetAddressToLineState( CATMemoryAddress::EXACT ); + + string s2; + size_t iLocation = s.find_first_of( ASCII_CHAR_CARRIAGE_RETURN ); + + bool bFunctionNameFoundUsingAddr2line = false; + + //Function name + + if(iLocation != string::npos ) + { + s2 = s.substr( 0, iLocation ); + //All characters ascii? + if( CATBase::IsAscii( s2.c_str(), (int)s2.length() ) ) + { + //addr2line returns $x if function name not found + //length must over 2 to be real function name + if( s2.length() > 2 ) + { + bFunctionNameFoundUsingAddr2line = true; + result->SetFunctionName( s2 ); + s.erase( 0, iLocation+2 ); + } + } + } + //If function name not found using addr2line find it from map file + if( !bFunctionNameFoundUsingAddr2line ) + { + string sFuncName( GetFunctionNameUsingAddress( uCountedA ) ); + //If function name empty, print "???" + if( sFuncName.empty() ) + { + s2 = "???"; + result->SetFunctionName( s2 ); + if(iLocation != string::npos ) + { + s.erase( 0, iLocation+2 ); + } + } + else + result->SetFunctionName( sFuncName ); + } + iLocation = s.find_first_of( ':' ); + + //Filename and location + + if(iLocation != string::npos ) + { + s2 = s.substr( 0, iLocation ); + result->SetFileName( s2 ); + s.erase( 0, iLocation+1 ); + } + + //Exact line number + + s2 = s.substr( 0, s.find_first_of( ASCII_CHAR_CARRIAGE_RETURN ) ); + result->SetExactLineNumber( atoi( s2.c_str() ) ); + } + return true; +} + +bool CATAddr2line::ReadMapFileArmv5() +{ + LOG_FUNC_ENTRY("CATModule2::ReadMapFileArmv5"); + // Open .map file + ifstream in( m_sMapFileName.c_str() ); + // File open ok? + if( ! in.good() ) + { + in.close(); + return false; + } + char cTemp[MAX_LINE_LENGTH]; + bool bFirstFuncFound = false; + bool bFirstLine = true; + // Get all lines where is "Thumb" + do + { + // Load one line from .map file + in.getline( cTemp, MAX_LINE_LENGTH ); + if( bFirstLine ) + { + bFirstLine = false; + if( strstr( cTemp, "ARM Linker" ) == NULL ) + return false; + } + // Find _E32Startup + if( !bFirstFuncFound && ( strstr( cTemp, "_E32Startup" ) != NULL) ) + { + bFirstFuncFound = true; + } + else if( !bFirstFuncFound && ( strstr( cTemp, "_E32Dll" ) != NULL) ) + { + bFirstFuncFound = true; + } + else if( !bFirstFuncFound ) + // Skip if _E32Startup not found + continue; + + if( strstr( cTemp, "Thumb Code" ) != NULL || strstr( cTemp, "ARM Code" ) != NULL) + { + MAP_FUNC_INFO structMapFileLineInfo; + structMapFileLineInfo.sWholeLine.append( cTemp ); + + // Get memory string address from line + char* pStart = strstr( cTemp, "0x" ); + // Check did strstr return null. + if ( pStart == NULL ) + continue; + char* pTemp = pStart; + char TempString[MAX_LINE_LENGTH]; + TempString[0] = 0; + size_t iLength = 0; + while( *pTemp != ' ' ) + { + TempString[iLength] = *pTemp; + pTemp++; + iLength++; + } + TempString[iLength] = 0; + + structMapFileLineInfo.iAddress = CATDatParser::_httoi( TempString ); + + pTemp = cTemp; + TempString[0] = 0; + + // Get function name + + // Skip spaces + while( *pTemp == ' ' ) + { + pTemp++; + } + iLength = 0; + // Find end of function name + string sTemp( pTemp ); + + // Location of character ')' + iLength = sTemp.find_first_of(')'); + + // Location of character ' ' + size_t iLength2 = sTemp.find_first_of(' '); + + // If ')' character is the last char and + // character ' ' is closer than ')' use location of ' ' + if( ( iLength + 1 ) == sTemp.length() && iLength2 < iLength ) + iLength = iLength2 - 1; + + if( iLength != string::npos ) + sTemp.resize( (iLength + 1) ); + + structMapFileLineInfo.sFunctionName.append( sTemp.c_str() ); + + bool bARM = false; + // Find function length + pStart = strstr( cTemp, "Thumb Code" ); + if( pStart == NULL ) + { + pStart = strstr( cTemp, "ARM Code" ); + bARM = true; + } + if( pStart != NULL ) + { + if( bARM ) + pStart += 8; + else + pStart += 10; + while(*pStart == ' ') + { + pStart++; + } + sTemp.clear(); + sTemp.append( pStart ); + size_t iSize = sTemp.find_first_of(' '); + if( iSize != string::npos ) + sTemp.resize( iSize ); + } + + structMapFileLineInfo.iFuncLength = atoi( sTemp.c_str() ); + if( bFirstFuncFound && structMapFileLineInfo.iFuncLength > 0 ) + // Save to list + m_vMapFileFuncList.push_back( structMapFileLineInfo ); + } + } + while( in.good() ); + in.close(); + return true; +} + +// Find function name of given address +string CATAddr2line::GetFunctionNameUsingAddress( unsigned long iAddress ) +{ + LOG_LOW_FUNC_ENTRY("CATAddr2line::GetSymbolIndexUsingAddress"); + string sRet; + for( size_t i = 0; i < m_vMapFileFuncList.size(); i++ ) + { + unsigned long iStart = m_vMapFileFuncList.at( i ).iAddress; + unsigned long iEnd = ( m_vMapFileFuncList.at( i ).iAddress + + m_vMapFileFuncList.at( i ).iFuncLength ); + + if ( iAddress >= iStart && iAddress < iEnd ) + return m_vMapFileFuncList.at( i ).sFunctionName; + } + return sRet; +} + +//Note: New filtering functions commented out until they are taken into use. +/** +* Filter string out of unwanted characters. +*/ +/* +void CATAddr2line::FilterString( string &sString ) +{ + LOG_LOW_FUNC_ENTRY("CATAddr2line::FilterString"); + string sFiltered(""); + for( size_t i = 0 ; i < sString.length() ; i++ ) + { + const char p = sString.at( i ); + if ( p != 0 && strchr( ADDR2LINEALLOWEDCHARS, p ) != 0 ) + sFiltered.push_back( p ); + } + sString = sFiltered; +} +*/ +/** +* Find line feed position from string. +*/ +/* +size_t CATAddr2line::FindLineFeed( const string& sString ) +{ + LOG_LOW_FUNC_ENTRY("CATAddr2line::FindLineFeed"); + size_t iLineFeed1 = sString.find( 12 ); + size_t iLineFeed2 = sString.find( 15 ); + if ( iLineFeed1 < iLineFeed2 && iLineFeed1 != string::npos ) + return iLineFeed1; + else if ( iLineFeed2 != string::npos ) + return iLineFeed2; + else + return string::npos; +} +*/ +/** +* Erase characters from start of the string until other char than linefeed found. +*/ +/* +void CATAddr2line::EraseUntilNoLineFeed( string& sString ) +{ + LOG_LOW_FUNC_ENTRY("CATAddr2line::EraseUntilNoLineFeed"); + for ( size_t i = 0 ; i < sString.length() ; i++ ) + { + if ( sString.at( i ) != 15 && sString.at( i ) != 12 ) + break; + } + sString.erase( 0, i ); +} +*/ +/** +* Split multiple line string with unexpected line feeds to vector of strings. +*/ +/* +vector CATAddr2line::SplitToStrings( string& sMultiLineString ) +{ + LOG_LOW_FUNC_ENTRY("CATAddr2line::SplitToStrings"); + vector vLines; + while ( 1 ) + { + size_t iLineFeed = FindLineFeed( sMultiLineString ); + if ( iLineFeed == string::npos ) + break; + string sCell = sMultiLineString.substr(0, iLineFeed ); + sMultiLineString.erase(0, iLineFeed ); + EraseUntilNoLineFeed( sMultiLineString ); + FilterString( sCell ); + vLines.push_back( sCell ); + } + // If no lines were found set single one. + if ( vLines.size() == 0 ) + vLines.push_back( sMultiLineString ); + return vLines; +} +*/ +//EOF diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/src/cataddr2lineserver.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/src/cataddr2lineserver.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,286 @@ +/* +* 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: Class representing a server that uses addr2line.exe. +* +*/ + +#include "../inc/cataddr2lineserver.h" +#include "../inc/CATBase.h" + +// ---------------------------------------------------------------------------- +// Constructor +// ---------------------------------------------------------------------------- +CATAddr2lineServer::CATAddr2lineServer() +{ + LOG_FUNC_ENTRY("CATAddr2lineServer::CATAddr2lineServer"); + m_bProcessCreated = false; + + // Pipe handles. + m_hChildErroutRd = 0; + m_hChildErroutRdDup = 0; + m_hChildErroutWr = 0; + m_hChildStdinRd = 0; + m_hChildStdinWr = 0; + m_hChildStdinWrDup = 0; + m_hChildStdoutRd = 0; + m_hChildStdoutWr = 0; + m_hChildStdoutRdDup = 0; + + m_hSaveErrout = 0; + m_hSaveStdin = 0; + m_hSaveStdout = 0; + + // Set the bInheritHandle flag so pipe handles are inherited. + m_saAttr.nLength = sizeof(SECURITY_ATTRIBUTES); + m_saAttr.bInheritHandle = TRUE; + m_saAttr.lpSecurityDescriptor = NULL; + + // Symbol file. + m_sFullPathAndBinaryName = ""; +} +// ---------------------------------------------------------------------------- +// Destructor +// ---------------------------------------------------------------------------- +CATAddr2lineServer::~CATAddr2lineServer() +{ + LOG_FUNC_ENTRY("CATAddr2lineServer::~CATAddr2lineServer"); + // Close the pipe handle so the child process stops reading. + CloseHandle(m_hChildStdinWrDup); + // Close the write end of the pipe + CloseHandle(m_hChildStdoutWr); + // Close the write end of the error pipe + CloseHandle(m_hChildErroutWr); +} +bool CATAddr2lineServer::Initialize( const string& sFullPathAndBinaryName ) +{ + LOG_FUNC_ENTRY("CATAddr2lineServer::Initialize"); + BOOL fSuccess; + m_sFullPathAndBinaryName = sFullPathAndBinaryName; + + // The steps for redirecting child process's STDOUT: + // 1. Save current STDOUT, to be restored later. + // 2. Create anonymous pipe to be STDOUT for child process. + // 3. Set STDOUT of the parent process to be write handle to + // the pipe, so it is inherited by the child process. + // 4. Create a noninheritable duplicate of the read handle and + // close the inheritable read handle. + + // Save the handle to the current STDOUT. + m_hSaveStdout = GetStdHandle(STD_OUTPUT_HANDLE); + + // Create a pipe for the child process's STDOUT. + if (! CreatePipe(&m_hChildStdoutRd, &m_hChildStdoutWr, &m_saAttr, 0)) + return PrintErrorAndExit( "Stdout pipe creation failed\n" ); + + // Set a write handle to the pipe to be STDOUT. + if (! SetStdHandle(STD_OUTPUT_HANDLE, m_hChildStdoutWr)) + return PrintErrorAndExit( "Redirecting STDOUT failed\n" ); + + // Create noninheritable read handle and close the inheritable read + // handle. + fSuccess = DuplicateHandle(GetCurrentProcess(), m_hChildStdoutRd, + GetCurrentProcess(), &m_hChildStdoutRdDup , 0, + FALSE, + DUPLICATE_SAME_ACCESS); + if( !fSuccess ) + return PrintErrorAndExit( "DuplicateHandle failed" ); + CloseHandle(m_hChildStdoutRd); + + // The steps for redirecting child process's STDIN: + // 1. Save current STDIN, to be restored later. + // 2. Create anonymous pipe to be STDIN for child process. + // 3. Set STDIN of the parent to be the read handle to the + // pipe, so it is inherited by the child process. + // 4. Create a noninheritable duplicate of the write handle, + // and close the inheritable write handle. + + // Save the handle to the current STDIN. + m_hSaveStdin = GetStdHandle(STD_INPUT_HANDLE); + + // Create a pipe for the child process's STDIN. + if (! CreatePipe(&m_hChildStdinRd, &m_hChildStdinWr, &m_saAttr, 0)) + return PrintErrorAndExit( "Stdin pipe creation failed\n" ); + + // Set a read handle to the pipe to be STDIN. + if (! SetStdHandle(STD_INPUT_HANDLE, m_hChildStdinRd)) + return PrintErrorAndExit( "Redirecting Stdin failed\n" ); + + // Duplicate the write handle to the pipe so it is not inherited. + + fSuccess = DuplicateHandle(GetCurrentProcess(), m_hChildStdinWr, + GetCurrentProcess(), &m_hChildStdinWrDup, 0, + FALSE, // not inherited + DUPLICATE_SAME_ACCESS); + if (! fSuccess) + return PrintErrorAndExit( "DuplicateHandle failed\n" ); + + CloseHandle(m_hChildStdinWr); + + // The steps for redirecting child process's ERROUT: + // 1. Save current STDOUT, to be restored later. + // 2. Create anonymous pipe to be STDOUT for child process. + // 3. Set STDOUT of the parent process to be write handle to + // the pipe, so it is inherited by the child process. + // 4. Create a noninheritable duplicate of the read handle and + // close the inheritable read handle. + + // Save the handle to the current STDOUT. + m_hSaveErrout = GetStdHandle( STD_ERROR_HANDLE ); + + // Create a pipe for the child process's ERROUT. + if (! CreatePipe(&m_hChildErroutRd, &m_hChildErroutWr, &m_saAttr, 0)) + return PrintErrorAndExit( "Errout pipe creation failed\n" ); + + // Set a write handle to the pipe to be ERROUT. + if (! SetStdHandle(STD_ERROR_HANDLE, m_hChildErroutWr)) + return PrintErrorAndExit( "Redirecting ERROUT failed\n" ); + + // Create noninheritable read handle and close the inheritable read + // handle. + + fSuccess = DuplicateHandle(GetCurrentProcess(), m_hChildErroutRd, + GetCurrentProcess(), &m_hChildErroutRdDup , 0, + FALSE, + DUPLICATE_SAME_ACCESS); + if( !fSuccess ) + return PrintErrorAndExit( "DuplicateHandle failed" ); + + CloseHandle(m_hChildErroutRd); + CloseHandle(m_hChildErroutRdDup); + + // Now create the child process. + fSuccess = CreateChildProcess(); + if (!fSuccess ) + return PrintErrorAndExit( "Create process failed\n" ); + + // After process creation, restore the saved STDIN and STDOUT. + if (! SetStdHandle(STD_INPUT_HANDLE, m_hSaveStdin)) + return PrintErrorAndExit( "Re-redirecting Stdin failed\n" ); + + if (! SetStdHandle(STD_OUTPUT_HANDLE, m_hSaveStdout)) + return PrintErrorAndExit( "Re-redirecting Stdout failed\n" ); + + if (! SetStdHandle(STD_ERROR_HANDLE, m_hSaveErrout)) + return PrintErrorAndExit( "Re-redirecting Stderrout failed\n" ); + + m_bProcessCreated = true; + return true; +} +BOOL CATAddr2lineServer::CreateChildProcess() +{ + LOG_FUNC_ENTRY("CATAddr2lineServer::CreateChildProcess"); + PROCESS_INFORMATION piProcInfo; + STARTUPINFO siStartInfo; + BOOL bFuncRetn = FALSE; + + // Set up members of the PROCESS_INFORMATION structure. + ZeroMemory( &piProcInfo, sizeof(PROCESS_INFORMATION) ); + + // Set up members of the STARTUPINFO structure. + ZeroMemory( &siStartInfo, sizeof(STARTUPINFO) ); + siStartInfo.cb = sizeof(STARTUPINFO); + + //atool.exe:s path + filename + char buffer[MAX_PATH]; + + GetModuleFileName( NULL, buffer, MAX_PATH ); + + string sCommand( buffer ); + + //Remove 'atool.exe' + size_t tPos = sCommand.rfind( "\\" ); + if ( tPos != string::npos ) + sCommand.resize( sCommand.rfind( "\\" )+1 ); + else + sCommand.clear(); + + sCommand.append( "addr2line.exe" ); + + //addr2line file exists + if( !CATBase::FileExists( sCommand.c_str() ) ) + return PrintErrorAndExit( "File not found addr2line.exe\n" ); + + //Sym file exists + if( !CATBase::FileExists( m_sFullPathAndBinaryName.c_str() ) ) + { + string sTemp( "File not found " ); + sTemp.append( m_sFullPathAndBinaryName ); + sTemp.append( "\n" ); + return PrintErrorAndExit( sTemp ); + } + + sCommand.append(" -f -C -e "); + sCommand.append( m_sFullPathAndBinaryName ); + + // Create the child process. + bFuncRetn = CreateProcess(NULL, + (LPSTR)sCommand.c_str(), // command line + NULL, // process security attributes + NULL, // primary thread security attributes + TRUE, // handles are inherited + 0, // creation flags + NULL, // use parent's environment + NULL, // use parent's current directory + &siStartInfo, // STARTUPINFO pointer + &piProcInfo); // receives PROCESS_INFORMATION + + if (bFuncRetn == 0) + { + //CreateProcess failed + return false; + } + else + { + CloseHandle(piProcInfo.hProcess); + CloseHandle(piProcInfo.hThread); + return bFuncRetn; + } +} +VOID CATAddr2lineServer::WriteToPipe( const string& sAddress ) +{ + LOG_LOW_FUNC_ENTRY("CATAddr2lineServer::WriteToPipe"); + DWORD dwRead, dwWritten; + CHAR chBuf[2]; //This is for enter key + + //Write data to a pipe. + dwRead = (DWORD)sAddress.length(); + WriteFile(m_hChildStdinWrDup, sAddress.c_str(), dwRead, &dwWritten, NULL); + + chBuf[0] = 0x0A; //Enter + chBuf[1] = 0; //NULL + //Write enter key to a pipe + WriteFile(m_hChildStdinWrDup, chBuf, 1, &dwWritten, NULL); +} +string CATAddr2lineServer::ReadFromPipe(VOID) +{ + LOG_LOW_FUNC_ENTRY("CATAddr2lineServer::ReadFromPipe"); + string s; + DWORD dwRead; + CHAR chBuf[BUFSIZE]; + // Read output from the child process, and save data to string. + ReadFile( m_hChildStdoutRdDup, chBuf, BUFSIZE, &dwRead, NULL); + s.append( chBuf ); + return s; +} +bool CATAddr2lineServer::GetProcessCreatedState( void ) +{ + LOG_LOW_FUNC_ENTRY("CATAddr2lineServer::GetProcessCreatedState"); + return m_bProcessCreated; +} +bool CATAddr2lineServer::PrintErrorAndExit( const string sInput ) +{ + LOG_FUNC_ENTRY("CATAddr2lineServer::PrintErrorAndExit"); + cout << AT_MSG << sInput; + return false; +} diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/src/catalloc.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/src/catalloc.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,64 @@ +/* +* 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: +* +*/ +#include "../inc/ATCommonDefines.h" +#include "../inc/catalloc.h" + +string CATAlloc::GetAllocString( void ) +{ + LOG_LOW_FUNC_ENTRY("CATAlloc::GetAllocString"); + // Create alloc string + string sLine(""); + sLine.append( m_sTime ); sLine.append(" " ); + sLine.append( m_sSize ); + + // Add all call stack fragments to line. + string sCallStack; + map::iterator it; + for( it = m_vCallStack.begin() ; it != m_vCallStack.end() ; it++ ) + { + sCallStack.append( (*it).second ); + sCallStack.append( " " ); + } + // Remove the last space + if ( sCallStack.size() > 0 ) + sCallStack.erase( sCallStack.size()-1, 1 ); + + if ( m_iCSCount != 0 ) + { + // Check integrity (calculate number of spaces in call stack) + unsigned long iCount = 0; + size_t pos = 0; + while ( pos != string::npos ) + { + iCount++; + pos = sCallStack.find_first_of( ' ', pos+1 ); + } + if ( iCount != m_iCSCount ) + cout << AT_MSG << "Error, integrity check failed in alloc." << endl; + } + + // Add call stack to line. + if ( sCallStack.size() > 0 ) + { + sLine.append(" " ); + sLine.append( sCallStack ); + } + + // return alloc line. + return sLine; +} + diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/src/catallocs.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/src/catallocs.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,176 @@ +/* +* 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: +* +*/ +#include "../inc/ATCommonDefines.h" +#include "../inc/catallocs.h" + +void CATAllocs::Alloc( const string& sAllocString ) +{ + LOG_LOW_FUNC_ENTRY("CATAllocs::Alloc"); + string sAlloc( sAllocString ); + CATAlloc alloc; + string sAddress = GetStringUntilNextSpace( sAlloc, true ); + alloc.m_sTime = GetStringUntilNextSpace( sAlloc, true ); + alloc.m_sSize = GetStringUntilNextSpace( sAlloc, true ); + alloc.m_vCallStack.insert( pair(1, sAlloc) ); + // Add allocation + pair< map::iterator, bool> ret; + ret = m_vAllocs.insert( pair( sAddress, alloc ) ); + if( ret.second == false ) + { + // Allocation to this memory address was already added. + LOG_STRING( "CATAllocs: Allocating same address again, address: " << sAddress ); + } +} + +void CATAllocs::AllocH( const string& sAllocHString ) +{ + LOG_LOW_FUNC_ENTRY("CATAllocs::AllocH"); + string sAllocH( sAllocHString ); + // Parse alloc & create new allocation. + CATAlloc alloc; + string sAddress = GetStringUntilNextSpace( sAllocH, true ); + alloc.m_sTime = GetStringUntilNextSpace( sAllocH, true ); + alloc.m_sSize = GetStringUntilNextSpace( sAllocH, true ); + alloc.m_iCSCount = _httoi( string( GetStringUntilNextSpace( sAllocH, true ) ).c_str() ); + // Insert call stack fragment as "first" 1 because we are header. + if ( alloc.m_iCSCount > 0 ) + alloc.m_vCallStack.insert( pair( 0, sAllocH ) ); + // Add allocation + pair< map::iterator, bool> ret; + ret = m_vAllocs.insert( pair( sAddress, alloc ) ); + if( ret.second == false ) + { + // Allocation to this memory address was already added. + LOG_STRING( "CATAllocs: Allocating same address again, address: " << sAddress ); + } +} + +void CATAllocs::AllocF( const string& sAllocFString ) +{ + LOG_LOW_FUNC_ENTRY("CATAllocs::AllocF"); + string sAllocF( sAllocFString ); + string sAddress = GetStringUntilNextSpace( sAllocF, true ); + string sTime = GetStringUntilNextSpace( sAllocF, true ); + unsigned long iNumber = _httoi( string( GetStringUntilNextSpace( sAllocF, true ) ).c_str() ); + string sCallSstack = sAllocF; + // Find correct allocation into which add call stack fragment. + map::iterator it; + it = m_vAllocs.find( sAddress ); + // TODO: If cannot find, create new in cache. + if ( it == m_vAllocs.end() ) + { + LOG_STRING( "CATAllocs: Allocate fragment without header: " << sAddress ); + return; + } + pair< map::iterator, bool> ret; + // Add call stack to it. + ret = it->second.m_vCallStack.insert( pair( iNumber, sCallSstack ) ); + if( ret.second == false ) + { + LOG_STRING( "CATAllocs: Same allocation fragment again: " << sAddress ); + } +} + +// Free message. +void CATAllocs::Free( const string& sFreeString ) +{ + LOG_LOW_FUNC_ENTRY("CATAllocs::Free"); + string sFree( sFreeString ); + string sKey = GetStringUntilNextSpace( sFree ); + // Find related allocation. + map::iterator it; + it = m_vAllocs.find( sKey ); + if ( it == m_vAllocs.end() ) + { + LOG_STRING( "CATAllocs: Free message which has no alloc pair: " << sKey ); + return; + } + // Delete it. + m_vAllocs.erase( it ); +} + +// FreeH. +void CATAllocs::FreeH( const string& sFreeH ) +{ + LOG_LOW_FUNC_ENTRY("CATAllocs::FreeH"); + // Current implementation does not use call stack of + // free message to anything. + string sFree( sFreeH ); + string sKey = GetStringUntilNextSpace( sFree ); + // Time stamp. (not used currently) + // Call stack count. (not used currently) + // Call stack data. (not used currently) + + // Find related allocation. + map::iterator it; + it = m_vAllocs.find( sKey ); + if ( it == m_vAllocs.end() ) + { + LOG_STRING( "CATAllocs: FreeH message which has no alloc pair: " << sKey ); + return; + } + // Delete it. + m_vAllocs.erase( it ); +} + +// FreeF. +void CATAllocs::FreeF( const string& /* sFreeF */ ) +{ + LOG_LOW_FUNC_ENTRY("CATAllocs::FreeF"); + // Fragments are currently ignored. + // Memory address. (not used currently) + // Time stamp. (not used currently) + // Packet number. (not used currently) + // Call stack data. (not used currently) +} + +// Get "leak" list ordered by allocation time. +void CATAllocs::GetLeakList( vector& vLeakList ) +{ + LOG_LOW_FUNC_ENTRY("CATAllocs::GetLeakList"); + + // Create multimap where key is timestamp. + // Add allocations there so they will go ascending order. + multimap mmap; + multimap::iterator itMmap; + + map::iterator it; + for( it = m_vAllocs.begin(); it != m_vAllocs.end() ; it++ ) + { + string sTime = it->second.m_sTime; + + string sLine = it->first; + sLine.append(" "); + sLine.append( it->second.GetAllocString() ); + + mmap.insert( pair( sTime, sLine ) ); + } + + // Iterate list to parameter vector. + vLeakList.clear(); + for ( itMmap = mmap.begin(); itMmap != mmap.end(); itMmap++ ) + vLeakList.push_back( itMmap->second ); +} + +// Clear alloc data. +void CATAllocs::ClearAllocs( void ) +{ + LOG_LOW_FUNC_ENTRY("CATAllocs::ClearAllocs"); + m_vAllocs.clear(); +} + +//EOF diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/src/catdbghelper.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/src/catdbghelper.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,314 @@ +/* +* 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: Windows debug api implementation for IAddressToLine interface. +* +*/ + +#include "../inc/catdbghelper.h" +#include "../inc/CATBase.h" +#include "../inc/CATMemoryAddress.h" +#include + +/** +* Notes on version number of api functions. +* 5.1 Windows XP +* 5.2 Windows Server 2003 +* 6.8 Debugging Tools for Windows 6.8 +* SymSetOptions DbgHelp.dll 5.1 or later +* SymSetSearchPath DbgHelp.dll 5.1 or later +* SymLoadModuleEx Versions 5.2 and 6.0 +* SymLoadModule64 DbgHelp.dll 5.1 or later +* SymFromAddr Versions 4.0 and 5.1 +* SymGetLineFromAddr64 DbgHelp.dll 5.1 or later +*/ + +// Wrapper class for symbol information package. +struct CSymbolInfo : public SYMBOL_INFO_PACKAGE +{ + CSymbolInfo() + { + si.SizeOfStruct = sizeof( SYMBOL_INFO ); + si.MaxNameLen = sizeof( name ); + } +}; + +// Wrapper class for line information container. +struct CLineInfo : public IMAGEHLP_LINE64 +{ + CLineInfo() + { + SizeOfStruct = sizeof( IMAGEHLP_LINE64 ); + } +}; + +CATDbgHelper::CATDbgHelper() +{ + LOG_FUNC_ENTRY("CATDbgHelper::CDbgHelper"); + // Set the some "default" base address. + m_BaseAddress = 0x2; + m_bMap = false; + m_pBinaryFile = NULL; +} + +CATDbgHelper::~CATDbgHelper() +{ + LOG_FUNC_ENTRY("CATDbgHelper::~CDbgHelper"); + // Close dbghelper only once. + if ( CDBGHELPER_OPEN ) + { + Close(); + } + if ( m_pBinaryFile ) + { + delete[] m_pBinaryFile; + m_pBinaryFile = NULL; + } +} + +bool CATDbgHelper::Open( const string& sParameter, const unsigned long iLong ) +{ + LOG_FUNC_ENTRY("CATDbgHelper::Open"); + // Verify that file exits. Version 5.1.2600.5512 of dbghelp.dll does not correctly + // return error code if missing image file. This can lead upto applicaton crash. + if ( ! CATBase::FileExists( sParameter.c_str() ) ) + { + LOG_STRING( "Missing image file: " << sParameter ); + return false; + } + + // Is it urel try read map? + if ( sParameter.find( "\\urel\\" ) != string::npos ) + { + string sMapFile = sParameter; + sMapFile.append( ".map" ); + ReadMapFile( sMapFile ); + } + + // Set base address used + m_BaseAddress = iLong + AT_VIRTUAL_OFFSET_DBGHELPER; + // Binary file (also referred as symbol). + size_t length = sParameter.length(); + if ( length == 0 ) + { + LOG_STRING("DbgHelp:Invalid binary parameter."); + return false; + } + + char* pChar = new char[ sParameter.length()+1 ]; + strcpy( pChar, sParameter.c_str() ); + // Have to be casted to PSTR before using dbg api. Even tho its typedef same. + // This will avoid access violations bug. + // Note pChar is not deleted because its the member pointer just casted its + // memory allocation freed in destructor. + if ( m_pBinaryFile ) + delete[] m_pBinaryFile; + + m_pBinaryFile = (PSTR) pChar; + + // Initialize dbghelper if not done only once. + if ( ! CDBGHELPER_OPEN ) + { + // Set symbol options + SymSetOptions( SYMOPT_LOAD_LINES | SYMOPT_DEBUG | SYMOPT_UNDNAME | SYMOPT_LOAD_ANYTHING ); + if ( !SymInitialize( GetCurrentProcess(), NULL, TRUE ) ) + { + LOG_STRING("DbgHelp:Error initializing dbghelper " << (int) GetLastError()); + return false; + } + LOG_STRING("DbgHelp:dbghelper opened."); + CDBGHELPER_OPEN = true; + } + + // Set symbol search path. + if ( !SymSetSearchPath( GetCurrentProcess(), NULL ) ) + { + LOG_STRING("DbgHelp:Error setting symbol search path " << (int) GetLastError()); + return false; + } + + // Load module. + DWORD64 ret; + ret = SymLoadModule64( GetCurrentProcess(), NULL, m_pBinaryFile, NULL, m_BaseAddress, NULL ); // 5.1 api version. + if ( ret != m_BaseAddress && ret != 0) + { + LOG_STRING("Dbghelp:Module load failed " << (int) GetLastError()); + return false; + } + CDBGHELPER_CLIENTS++; + return true; +} + +string CATDbgHelper::GetError( void ) +{ + LOG_FUNC_ENTRY("CATDbgHelper::GetError"); + return string("not implemented."); +} + +bool CATDbgHelper::Close( void ) +{ + LOG_FUNC_ENTRY("CATDbgHelper::Close"); + if ( ! SymUnloadModule64( GetCurrentProcess(), m_BaseAddress ) ) + { + LOG_STRING("Dbghelp:Module unload failed."); + } + CDBGHELPER_CLIENTS--; + if ( CDBGHELPER_OPEN && CDBGHELPER_CLIENTS == 0) + { + // Cleanup dbghelper. + if ( ! SymCleanup( GetCurrentProcess() ) ) + { + LOG_STRING("dbghelper cleanup failed."); + return false; + } + LOG_STRING("dbghelper closed."); + // Set state not opened. + CDBGHELPER_OPEN = false; + } + return true; +} + +bool CATDbgHelper::AddressToLine( CATMemoryAddress* result ) +{ + LOG_FUNC_ENTRY("CATDbgHelper::AddressToLine"); + + // Set state out of range + result->SetAddressToLineState( CATMemoryAddress::OUT_OF_RANGE ); + + // check that dbghelper has been initialized successfully. + if ( ! CDBGHELPER_OPEN ) + return false; + + // Check has binary been moved, if so unload and load to new base address. + if ( result->GetModuleStartAddress() + AT_VIRTUAL_OFFSET_DBGHELPER != m_BaseAddress ) + { + // Unload. + if ( SymUnloadModule64( GetCurrentProcess(), m_BaseAddress ) ) + { + // Set new base address. + m_BaseAddress = result->GetModuleStartAddress() + AT_VIRTUAL_OFFSET_DBGHELPER; + // (Re)load. + DWORD64 loading = SymLoadModule64( GetCurrentProcess(), NULL, m_pBinaryFile, NULL, m_BaseAddress, NULL ); + if ( loading != m_BaseAddress && loading != 0) + { + LOG_STRING("Dbghelp:Module load failed " << (int) GetLastError()); + return false; + } + } + else + LOG_STRING("Dbghelp:Module unload failed " << (int) GetLastError() ); + } + // Address to find (offset+given address). + unsigned long iAddressToFind = result->GetAddress() + AT_VIRTUAL_OFFSET_DBGHELPER; + // Displacements of line/symbol information. + DWORD64 displacementSymbol; + DWORD displacementLine; + // Structure to get symbol information. + CSymbolInfo symbol; + // Structure to get line information. + CLineInfo line; + // Find Symbol for given address + if( ! SymFromAddr( GetCurrentProcess(), iAddressToFind , &displacementSymbol, &symbol.si ) ) + { + LOG_STRING("Failed to find symbol information for given line."); + return AddressToFunction( result ); + } + // Find line information + if( ! SymGetLineFromAddr64( GetCurrentProcess(), iAddressToFind, &displacementLine, &line ) ) + { + // If it fails get symbol line information + LOG_STRING("Dbghelp:Failed to find line information for address, trying for symbol of address."); + if( ! SymGetLineFromAddr64( GetCurrentProcess(), symbol.si.Address, &displacementLine, &line ) ) + { + LOG_STRING("Dbghelp:Failed to find line information for symbol address."); + return AddressToFunction( result ); + } + } + // Set the results. + result->SetFileName( string( line.FileName ) ); + result->SetFunctionName( string( symbol.si.Name ) ); + result->SetExactLineNumber( (int) line.LineNumber ); + result->SetAddressToLineState( CATMemoryAddress::EXACT ); + // Return. + return true; +} + +bool CATDbgHelper::AddressToFunction( CATMemoryAddress* result ) +{ + LOG_FUNC_ENTRY("CATDbgHelper::AddressToFunction"); + bool bFound = false; + // If map file read use it and return. + if ( m_bMap ) + { + ULONG uCountedA = result->GetOffSetFromModuleStart(); + for ( vector::iterator it = m_vMapFileFuncList.begin() ; it != m_vMapFileFuncList.end() ; it++ ) + { + // Check is this the symbol where address is. + unsigned long iStart = it->iAddress; + unsigned long iEnd = it->iAddress + it->iFuncLength; + if ( uCountedA >= iStart + && uCountedA < iEnd ) + { + result->SetAddressToLineState( CATMemoryAddress::SYMBOL ); + result->SetFunctionName( it->sMangledName ); + bFound = true; + break; + } + } + } + return bFound; +} + +void CATDbgHelper::ReadMapFile( const string sMapFileName ) +{ + LOG_FUNC_ENTRY("CATDbgHelper::ReadMapFile"); + try { + ifstream in( sMapFileName.c_str() ); + if ( ! in.good() ) + { + in.close(); + return; + } + char cLine[MAX_LINE_LENGTH]; + do { + in.getline( cLine, MAX_LINE_LENGTH ); + // Search pattern for 'image ro' symbols is ".text" + string sLine( cLine ); + if ( sLine.find( ".text" ) != string::npos ) + { + MAP_FUNC_INFO symbol; + // Pickup symbol attributes + // Address + string sAddress = CATBase::GetStringUntilNextSpace( sLine, true ); + symbol.iAddress = CATBase::_httoi( sAddress.c_str() ); + // Lenght + string sLength = CATBase::GetStringUntilNextSpace( sLine, true ); + symbol.iFuncLength = CATBase::_httoi( sLength.c_str() ); + // Name + size_t iStart = sLine.find_first_of( '(' ); + size_t iEnd = sLine.find_last_of( ')' ); + if ( iStart != string::npos && iEnd != string::npos ) + { + symbol.sMangledName = sLine.substr( iStart+1, iEnd-iStart-1 ); + // Add symbol to vector + m_vMapFileFuncList.push_back( symbol ); + } + } + } while ( in.good() ); + in.close(); + m_bMap = true; + } catch (...) { + m_bMap = false; + LOG_STRING("DbgHelp: Error reading map file."); + } +} \ No newline at end of file diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/src/catfilereader.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/src/catfilereader.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,111 @@ +/* +* 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: Class for reading ascii files in AnalyzeTool. +* +*/ + +#include "../inc/ATCommonDefines.h" +#include "../inc/catfilereader.h" + +// ----------------------------------------------------------------------------- +// CATFileReader::CATFileReader +// Constructor. +// ----------------------------------------------------------------------------- +CATFileReader::CATFileReader() +{ + LOG_FUNC_ENTRY("CATFileReader::CATFileReader"); + m_cDelimiter = '\r'; // default line delimeter +} + +// ----------------------------------------------------------------------------- +// CATFileReader::~CATFileReader +// Destructor. +// ----------------------------------------------------------------------------- +CATFileReader::~CATFileReader() +{ + LOG_FUNC_ENTRY("CATFileReader::~CATFileReader"); +} + +// ----------------------------------------------------------------------------- +// CATFileReader::Open +// Open / Read file. +// ----------------------------------------------------------------------------- +bool CATFileReader::Open( const char* cFile ) +{ + LOG_FUNC_ENTRY("CATFileReader::Open"); + if ( strlen( cFile ) < 1 ) + { + LOG_STRING("CATFileReader::Open empty file argument."); + return false; + } + try { + ifstream in; + in.open( cFile, ios::binary ); + if ( ! in.good() ) + return false; + m_stream << in.rdbuf(); + in.close(); + } + catch(...) + { + LOG_STRING("CATFileReader::Open unhandled exception."); + return false; + } + return true; +} + +// ----------------------------------------------------------------------------- +// CATFileReader::Close +// Close file. +// ----------------------------------------------------------------------------- +bool CATFileReader::Close( void ) +{ + LOG_FUNC_ENTRY("CATFileReader::Close"); + return true; +} + +// ----------------------------------------------------------------------------- +// CATFileReader::GetLine +// Get line from file. +// ----------------------------------------------------------------------------- +bool CATFileReader::GetLine( string& sLine ) +{ + //LOG_FUNC_ENTRY("CATFileReader::GetLine"); + char cLine[MAX_LINE_LENGTH]; + if ( !m_stream.good() ) + return false; + m_stream.getline( cLine, MAX_LINE_LENGTH, m_cDelimiter ); m_stream.get(); + sLine = cLine; + return true; +} + +// ----------------------------------------------------------------------------- +// CATFileReader::SetDelimiter +// Set line delimiting character. +// ----------------------------------------------------------------------------- +void CATFileReader::SetDelimiter( char cDelimiter ) +{ + LOG_FUNC_ENTRY("CATFileReader::SetDelimiter"); + m_cDelimiter = cDelimiter; +} + +// ----------------------------------------------------------------------------- +// CATFileReader::GetDelimiter +// Get current line delimiting character. +// ----------------------------------------------------------------------------- +char CATFileReader::GetDelimiter() const +{ + LOG_FUNC_ENTRY("CATFileReader::GetDelimiter()"); + return m_cDelimiter; +} \ No newline at end of file diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/src/catromsymbol.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/src/catromsymbol.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,656 @@ +/* +* 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: Reads rom symbol file and provides interface to acquire +* binary and function information using memory addresss. +* +*/ + +#include "../inc/ATCommonDefines.h" +#include "../inc/catromsymbol.h" +#include "../inc/catfilereader.h" +#include "../inc/CATBase.h" +#include "../inc/CATMemoryAddress.h" + +// ----------------------------------------------------------------------------- +// RofsBinary::RofsBinary +// Default construcor +// ----------------------------------------------------------------------------- +RofsBinary::RofsBinary() +{ + LOG_LOW_FUNC_ENTRY("RofsBinary::RofsBinary"); + m_sBinary = ""; + vSymbols.clear(); +} + +// ----------------------------------------------------------------------------- +// RofsBinary::RofsBinary +// Construcor +// ----------------------------------------------------------------------------- +RofsBinary::RofsBinary( const string& sBinary ) +{ + LOG_LOW_FUNC_ENTRY("RofsBinary::RofsBinary"); + m_sBinary = sBinary; + vSymbols.clear(); +} + +// ----------------------------------------------------------------------------- +// RofsBinary::~RofsBinary +// Destructor +// ----------------------------------------------------------------------------- +RofsBinary::~RofsBinary() +{ + LOG_LOW_FUNC_ENTRY("RofsBinary::~RofsBinary"); + for ( vector::iterator it = vSymbols.begin() ; it != vSymbols.end() ; it++ ) + delete *it; + vSymbols.clear(); +} + +// ----------------------------------------------------------------------------- +// CATRomSymbol::CATRomSymbol +// Constructor. +// ----------------------------------------------------------------------------- +CATRomSymbol::CATRomSymbol() +{ + LOG_FUNC_ENTRY("CATRomSymbol::CATRomSymbol"); + m_bSymbolsRead = false; + m_iRomEndAddress = 0; + m_iRomStartAddress = 0; + m_vRomFiles.clear(); + m_sErrorMessage = ""; + m_vRomCache.clear(); + m_vRomSymbols.clear(); + m_bShowProgressMessages = false; +} + +// ----------------------------------------------------------------------------- +// CATRomSymbol::~CATRomSymbol +// Destructor. +// ----------------------------------------------------------------------------- +CATRomSymbol::~CATRomSymbol() +{ + LOG_FUNC_ENTRY("CATRomSymbol::~CATRomSymbol"); + // Rom + for ( vector::iterator it = m_vRomSymbols.begin() ; it != m_vRomSymbols.end() ; it++ ) + { + delete *it; + } + m_vRomSymbols.clear(); + // Rofs + for ( vector::iterator it = m_vRofsBinaries.begin() ; it != m_vRofsBinaries.end() ; it++ ) + { + delete *it; + } + m_vRofsBinaries.clear(); +} + +// ----------------------------------------------------------------------------- +// CATRomSymbol::Open +// This funtion should not be used anymore since +// we support multiple rom/rofs files. +// ----------------------------------------------------------------------------- +bool CATRomSymbol::Open( const string& /*sString*/, const unsigned long /*iLong*/) +{ + LOG_FUNC_ENTRY("CATRomSymbol::Open"); + return false; +} + +// ----------------------------------------------------------------------------- +// CATRomSymbol::SetSymbols +// Set symbol file(s) to be used. +// This also checks that files exists and identifies them as rom/rofs. +// ----------------------------------------------------------------------------- +bool CATRomSymbol::SetSymbols( const vector& vSymbols ) +{ + LOG_FUNC_ENTRY("CATRomSymbol::SetSymbols"); + bool ok = true; + // Check no same symbol defined twice. + for( vector::const_iterator it = vSymbols.begin() ; + it != vSymbols.end(); it++ ) + { + for( vector::const_iterator it2 = vSymbols.begin() ; + it2 != vSymbols.end(); it2++ ) + { + if ( it == it2 ) + continue; + if ( _stricmp( (*it).c_str(), (*it2).c_str() ) == 0 ) + { + m_sErrorMessage.append( "Same symbol file defined twice (" ); + m_sErrorMessage.append( (*it) ); + m_sErrorMessage.append( ")\n" ); + return false; + } + } + } + // Loop given symbol files. + for( vector::const_iterator it = vSymbols.begin() ; + it != vSymbols.end(); it++ ) + { + // Symbol file exists? + if ( ! CATBase::FileExists( (*it).c_str() ) ) + { + ok = false; + m_sErrorMessage.append( "Symbol file does not exists (" ); + m_sErrorMessage.append( *it ); + m_sErrorMessage.append( ").\n"); + continue; + } + // Identify symbol file. + int type = IdentifySymbolFile( *it ); + // Depending on type move it correct vector. + switch( type ) + { + case SYMBOL_FILE_INVALID: + ok = false; + m_sErrorMessage.append( "Symbol file with invalid content (" ); + m_sErrorMessage.append( *it ); + m_sErrorMessage.append( ").\n"); + break; + case SYMBOL_FILE_ROM: + m_vRomFiles.push_back( *it ); + break; + case SYMBOL_FILE_ROFS: + m_vRofsFiles.push_back( *it ); + break; + default: + ok = false; + LOG_STRING("IdentifySymbolFile returned unknown type."); + break; + } + } + if ( ok ) + { + // Read symbols. + if ( m_vRomFiles.size() > 0 ) + { + if ( ! ReadRomFiles() ) + ok = false; + else + m_bSymbolsRead = true; + } + if ( m_vRofsFiles.size() > 0 ) + { + if ( ! ReadRofsFiles() ) + ok = false; + else + m_bSymbolsRead = true; + } + } + return ok; +} + +// ----------------------------------------------------------------------------- +// CATRomSymbol::IdentifySymbolFile +// Identify given file is it rom / rofs. +// ----------------------------------------------------------------------------- +int CATRomSymbol::IdentifySymbolFile( const string& sFile ) +{ + LOG_FUNC_ENTRY("CATRomSymbol::IdentifySymbolFile"); + // Set type as invalid. + int iType = SYMBOL_FILE_INVALID; + // Line counter. + int iLineCount = 0; + // Minimun line length to identify it. + size_t iLineMinLength = MAX_LINE_LENGTH; + if ( ROFS_SYMBOL_IDENTIFY_STRING.length() > ROM_SYMBOL_IDENTIFY_STRING.length() ) + iLineMinLength = ROFS_SYMBOL_IDENTIFY_STRING.length(); + else + iLineMinLength = ROM_SYMBOL_IDENTIFY_STRING.length(); + try { + ifstream in; + in.open( sFile.c_str(), ios::in ); + if ( ! in.good() ) + return SYMBOL_FILE_INVALID; + char cLine[MAX_LINE_LENGTH]; + do { + // Dont read too many lines. (File might be contain invalid data). + iLineCount++; + if ( iLineCount > IDENTIFY_MAX_LINES_READ ) + break; + + // Get line -> string. + in.getline( cLine, MAX_LINE_LENGTH ); + string sLine(cLine); + + // Check its not too short. + if( sLine.length() < iLineMinLength ) + continue; + + // Take substring from start of line to identify it to rofs/rom. + if ( ! sLine.substr( 0, ROFS_SYMBOL_IDENTIFY_STRING.length() ).compare( ROFS_SYMBOL_IDENTIFY_STRING ) ) + { + iType = SYMBOL_FILE_ROFS; + break; + } + else if ( ! sLine.substr( 0, ROM_SYMBOL_IDENTIFY_STRING.length() ).compare( ROM_SYMBOL_IDENTIFY_STRING ) ) + { + iType = SYMBOL_FILE_ROM; + break; + } + } while ( in.good() ); + in.close(); + } + catch(...) + { + LOG_STRING("CATRomSymbol::IdentifySymbolFile unhandled exception."); + } + return iType; +} + +// ----------------------------------------------------------------------------- +// CATRomSymbol::ReadRomFiles +// Reads rom file(s) and creates symbols to vector. +// ----------------------------------------------------------------------------- +bool CATRomSymbol::ReadRomFiles() +{ + LOG_FUNC_ENTRY("CATRomSymbol::ReadRomFile"); + + // Clear symbols. + for ( vector::iterator it = m_vRomSymbols.begin() ; it != m_vRomSymbols.end() ; it++ ) + { + delete *it; + } + m_vRomSymbols.clear(); + + // Clear cache. note cache is just pointers dont delete them. + m_vRomCache.clear(); + + // Any errors? + bool ok = true; + + for( vector::iterator it = m_vRomFiles.begin(); + it != m_vRomFiles.end() ; it++ ) + ok = ReadRomFile( *it ); + + // If size smaller than 1 it is not good rom file(s). + if ( m_vRomSymbols.size() < 1 || ok != true) + return false; + + // Rom start and end addresses. + m_iRomStartAddress = (*m_vRomSymbols.begin())->iStartAddress; + m_iRomEndAddress = (*m_vRomSymbols.rbegin())->iEndAddress; + return true; +} + +// ----------------------------------------------------------------------------- +// CATRomSymbol::ReadRofsFiles +// Read rofs files. +// ----------------------------------------------------------------------------- +bool CATRomSymbol::ReadRofsFiles() +{ + LOG_FUNC_ENTRY("CATRomSymbol::ReadRofsFiles"); + // Clear. + for ( vector::iterator it = m_vRofsBinaries.begin() ; it != m_vRofsBinaries.end() ; it++ ) + { + delete *it; + } + m_vRofsBinaries.clear(); + + // Any errors? + bool ok = true; + + for( vector::iterator it = m_vRofsFiles.begin(); + it != m_vRofsFiles.end() ; it++ ) + ok = ReadRofsFile( *it ); + + // If size smaller than 1 it is not good rofs file(s). + if ( m_vRofsBinaries.size() < 1 || ok != true) + return false; + return true; +} + +// ----------------------------------------------------------------------------- +// CATRomSymbol::ReadRomFile +// Read given rom file +// ----------------------------------------------------------------------------- +bool CATRomSymbol::ReadRomFile( const string& sFile ) +{ + LOG_FUNC_ENTRY("CATRomSymbol::ReadRomfile"); + // Open rom file. + CATFileReader* reader = new CATFileReader(); + // Show progress message if flag set. + if ( m_bShowProgressMessages ) + cout << AT_MSG << "Reading rom symbol file: " << sFile << "..." << endl; + if ( ! reader->Open( sFile.c_str() ) ) + { + reader->Close(); + delete reader; + return false; + } + + // Show progress message if flag set. + if ( m_bShowProgressMessages ) + cout << AT_MSG << "Parsing rom symbol file: " << sFile << "..." << endl; + + // Loop thrue lines. + string sLine(""); + string sBinary(""); + while( reader->GetLine( sLine ) ) + { + // From rom we just read symbols that have lenght, no need to separate them into diff binaries. + try { + if ( sLine.size() < 2 ) + { + continue; + } + else if ( sLine.at(0) == '8' ) + { + // Create new item. + Symbol* symbol = new Symbol(); + ParseSymbolFromLine( sLine, symbol); + // Ignore symbols which have same start & end address (zero length). + if ( symbol->iStartAddress != symbol->iEndAddress ) + m_vRomSymbols.push_back( symbol ); + else + delete symbol; + } + } catch(...) + { + // Catch all possible exception here so analyze will succeed even rom file invalid. + m_sErrorMessage.append( "Unhandled exception parsing rom symbol file.\n" ); + // Close and delete reader. + reader->Close(); + delete reader; + return false; + } + } + // Close and delete reader. + reader->Close(); + delete reader; + return true; +} + +// ----------------------------------------------------------------------------- +// CATRomSymbol::ReadRofsFile +// Read given rofs file +// ----------------------------------------------------------------------------- +bool CATRomSymbol::ReadRofsFile( const string& sFile ) +{ + LOG_FUNC_ENTRY("CATRomSymbol::ReadRofsFile"); + // open/read rofs file. + CATFileReader* reader = new CATFileReader(); + // Show progress message if flag set. + if ( m_bShowProgressMessages ) + cout << AT_MSG << "Reading rofs symbol file: " << sFile << "..." << endl; + if ( ! reader->Open( sFile.c_str() ) ) + { + reader->Close(); + delete reader; + return false; + } + + // Show progress message if flag set. + if ( m_bShowProgressMessages ) + cout << AT_MSG << "Parsing rofs symbol file: " << sFile << "..." << endl; + + // Loop thrue lines. + string sLine(""); + string sBinary(""); + RofsBinary* rb = NULL; + while( reader->GetLine( sLine ) ) + { + try { + if ( sLine.size() < 2 ) + { + continue; + } + else if ( sLine.at(0) == 'F' ) + { + if ( rb != NULL ) + { + // Check last binary if no symbols in it dont add it. + if ( rb->vSymbols.size() == 0 ) + { + delete rb; + rb = NULL; + } + else + m_vRofsBinaries.push_back( rb ); + } + // new binary name. + size_t i = sLine.rfind("\\"); + sLine.erase(0, i+1); + rb = new RofsBinary( sLine ); + + } + else if ( sLine.at(0) == '0' ) + { + // Cannot pickup symbols if no binary defined. + if ( rb == NULL ) + continue; + // Create new item. + Symbol* symbol = new Symbol(); + ParseSymbolFromLine( sLine, symbol); + // Ignore symbols which have same start & end address (zero length). + if ( symbol->iStartAddress != symbol->iEndAddress ) + rb->vSymbols.push_back( symbol ); + else + delete symbol; + } + } catch(...) + { + // Catch all possible exception here so analyze will succeed even rofs file invalid. + m_sErrorMessage.append( "Unhandled exception parsing rofs symbol file.\n" ); + // Close and delete reader. + reader->Close(); + delete reader; + return false; + } + } + // Last added binary. + if ( rb != NULL ) + { + if ( rb->vSymbols.size() == 0 ) + { + delete rb; + rb = NULL; + } + else + m_vRofsBinaries.push_back( rb ); + } + // Close and delete reader. + reader->Close(); + delete reader; + return true; +} + +// ----------------------------------------------------------------------------- +// CATRomSymbol::ParseSymbolFromLine +// Parses given line into given symbol. +// ----------------------------------------------------------------------------- +void CATRomSymbol::ParseSymbolFromLine( const string& sLine, Symbol* pSymbol ) +{ + LOG_LOW_FUNC_ENTRY("CATRomSymbol::ParseSymbolFromLine"); + if ( pSymbol == NULL ) + return; + size_t s,x; + string temp; + // address. + x = sLine.find( ' ' ); + temp = sLine.substr( 0, x ); + pSymbol->iStartAddress = CATBase::_httoi( temp.c_str() ); + // "Erase spaces" move starting point. + s = x; + s = sLine.find_first_not_of( ' ', s ); + // length. + x = sLine.find( ' ', s ); + temp = sLine.substr(s,x-s); + unsigned long length = CATBase::_httoi( temp.c_str() ); + pSymbol->iEndAddress = pSymbol->iStartAddress + length; + // "Erase spaces" move starting point. + s = x; + s = sLine.find_first_not_of( ' ', s); + // function. Function might have spaces so we find 2 spaces which indicates end of it. + x = sLine.find( " ", s ); + temp = sLine.substr( s, x-s ); + pSymbol->sFunction = temp; +} + +// ----------------------------------------------------------------------------- +// CATRomSymbol::GetError +// Get error string if error occured in other methods. +// ----------------------------------------------------------------------------- +string CATRomSymbol::GetError( void ) +{ + LOG_FUNC_ENTRY("CATRomSymbol::GetError"); + return m_sErrorMessage; +} + +// ----------------------------------------------------------------------------- +// CATRomSymbol::Close +// Close (stop using). +// ----------------------------------------------------------------------------- +bool CATRomSymbol::Close( void ) +{ + LOG_FUNC_ENTRY("CATRomSymbol::Close"); + return true; +} + +// ----------------------------------------------------------------------------- +// CATRomSymbol::AddressToLine +// Try locate binary and function name for given memory address. +// ----------------------------------------------------------------------------- +bool CATRomSymbol::AddressToLine( CATMemoryAddress* result ) +{ + LOG_LOW_FUNC_ENTRY("CATRomSymbol::AddressToLine"); + // Have symbols been read. + if ( ! m_bSymbolsRead ) + return false; + // check that its lenght > 2 + if ( result->GetAddressString().size() < 2 ) + return false; + /* Check first is address in range of rom */ + if ( result->GetAddress() < m_iRomStartAddress + || result->GetAddress() > m_iRomEndAddress ) + { + return AddressToLineRofs( result ); + } + return AddressToLineRom( result ); +} + +// ----------------------------------------------------------------------------- +// CATRomSymbol::AddressToLineRom +// Locate function from rom address range. +// ----------------------------------------------------------------------------- +bool CATRomSymbol::AddressToLineRom( CATMemoryAddress* result ) +{ + LOG_LOW_FUNC_ENTRY( "CATRomSymbol::AddressToLineRom" ); + // Address to find in integer & string. + unsigned long iAddressToFind = result->GetAddress(); + string sAddressToFind = result->GetAddressString(); + + // Find symbol. + Symbol* pFound = NULL; + + // Check from cache first. + vector::iterator it; + for ( it = m_vRomCache.begin(); it != m_vRomCache.end(); it++ ) + { + if ( iAddressToFind >= (*it)->iStartAddress + && (*it)->iEndAddress > iAddressToFind ) + { + pFound = *it; + break; + } + } + + if ( pFound == NULL ) + { + // From all symbols. + bool reverse = false; + int offSetFromStart = iAddressToFind - m_iRomStartAddress; + int offSetFromEnd = m_iRomEndAddress - iAddressToFind; + if ( offSetFromEnd < offSetFromStart ) + reverse = true; + + if ( reverse ) + { + // Iterate vector in reverse. + vector::reverse_iterator it; + for ( it = m_vRomSymbols.rbegin(); it != m_vRomSymbols.rend(); ++it ) + { + if ( iAddressToFind >= (*it)->iStartAddress + && (*it)->iEndAddress > iAddressToFind ) + { + pFound = *it; + break; + } + } + } + else + { + // Iterate vector normal direction. + vector::iterator it; + for ( it = m_vRomSymbols.begin(); it != m_vRomSymbols.end(); it++ ) + { + if ( iAddressToFind >= (*it)->iStartAddress + && (*it)->iEndAddress > iAddressToFind ) + { + pFound = *it; + break; + } + } + } + } + + // Set result if found. + if ( pFound != NULL ) + { + result->SetFunctionName( pFound->sFunction ); + result->SetAddressToLineState( CATMemoryAddress::SYMBOL ); + // Add found symbols pointer to cache. + m_vRomCache.push_back( pFound ); + return true; + } + return false; +} + +// ----------------------------------------------------------------------------- +// CATRomSymbol::AddressToLineRofs +// Locate function from rofs address range. +// ----------------------------------------------------------------------------- +bool CATRomSymbol::AddressToLineRofs( CATMemoryAddress* result) +{ + LOG_LOW_FUNC_ENTRY("CATRomSymbol::AddressToLineRofs"); + // Check that binary name is defined in memory address. + string sBinary = result->GetModuleName(); + if ( sBinary.empty() ) + return false; + // Try find that named module. + vector::iterator rofs = m_vRofsBinaries.begin(); + while( rofs != m_vRofsBinaries.end() ) + { + if ( (*rofs)->m_sBinary.compare( sBinary ) == 0 ) + break; + rofs++; + } + if ( rofs == m_vRofsBinaries.end() ) + return false; + + // Offset what we are looking from binary + unsigned long offSet = result->GetAddress(); + offSet -= result->GetModuleStartAddress(); + for( vector::iterator it = (*rofs)->vSymbols.begin() ; + it != (*rofs)->vSymbols.end(); it++ ) + { + if ( (*it)->iStartAddress <= offSet && offSet < (*it)->iEndAddress ) + { + result->SetFunctionName( (*it)->sFunction ); + result->SetAddressToLineState( CATMemoryAddress::SYMBOL ); + return true; + } + } + return false; +} + +//EOF diff -r d27dfa8884ad -r da2cedce4920 analyzetool/commandlineengine/src/helps.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/commandlineengine/src/helps.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,180 @@ +/* +* 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: Contains help texts for CLE. +* +*/ +#include "../inc/ATCommonDefines.h" + +//Function declarations +void print_help( void ); +void print_syntax_examples( void ); + +/** +* Print help info. +*/ +void print_help( void ) +{ + cout<< "AnalyzeTool v"; + cout<< ATOOL_VERSION; + cout<< " - "; + cout<< ATOOL_DATE; + cout<< "\n"; + cout<< "Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).\nAll rights reserved.\n\n"; + cout<< "Usage:\n"; + cout<< "atool -e [optional parameters] abld [abld parameters]\n"; + cout<< " -me [optional parameters] abld [abld parameters]\n"; + cout<< " -mi [optional parameters] [-f data-file] sbs [sbs parameters]\n"; + cout<< " -a data-file [output-file] [-s symbol-file] [-l#]\n"; + cout<< " -p data-file output-file\n"; + cout<< " -c\n"; + cout<< " -v\n"; + cout<< " -help\n"; + cout<< "\n"; + cout<< "Mandatory parameter to choose:\n"; + cout<< " -e Build project for analysis using external data gathering.\n"; + cout<< " -me Build project for analysis using monitored external\n"; + cout<< " data gathering.\n"; + cout<< " -mi Build project for analysis using monitored internal\n"; + cout<< " data gathering.\n"; + cout<< " abld... Use SBS v.1 build system with defined build command,\n"; + cout<< " which includes supported platform and build type.\n"; + cout<< " sbs... Use SBS v.2 (Raptor) build system with defined sbs build\n"; + cout<< " command, which includes supported platform and build type.\n"; + cout<< " -a Analyze report file.\n"; + cout<< " -c Clear AnalyzeTool changes, temporary files and releasable(s).\n"; + cout<< " -p Parse trace file to data file.\n"; + cout<< " -help Show full help including syntax examples.\n"; + cout<< " -v Print version info.\n"; + cout<< "\n"; + + cout<< "Optional parameters:\n"; + cout<< " -acs size Specifies the call stack size gathered when memory\n"; + cout<< " is allocated. Size can be between 0-256.\n"; + cout<< " -fcs size Specifies the call stack size gathered when memory is freed.\n"; + cout<< " Size can be between 0-256.\n"; + cout<< " -f data file Specifies the filename for monitored internal data gathering\n"; + cout<< " (50 chars max). Cannot contain path.\n"; + cout<< " output-file Specifies the results data file name.\n"; + cout<< " -l Logging level of analyze report(0,1,2,3), default 3.\n"; + cout<< " -s symbol-file Specifies rom/rofs symbol file(s) to be used in analyze.\n"; + cout<< " Multiple -s options can be given.\n"; + cout<< " -nobuild Instruments the project.\n"; + //cout<< " -show_debug Print debug messages to console.\n"; + //cout<< " -show_debug_all Print debug messages to console (all).\n"; + //cout<< " -show_dbgview Print debug messages to windows debug api.\n"; + //cout<< " -show_dbgview_all Print debug messages to windows debug api (all).\n"; + + /* + * Old style parameters, just for notes. + printf("Usage:\n"); + printf("atool -m [mmp-file] [mode] [data-file] [-variant variant-name] [build] [-sbs2] [-e]\n"); + printf(" -i [mmp-file] [mode] [data-file] [-variant variant-name] [build] [-sbs2] [-e]\n"); + printf(" -a [mmp-file | target-name] data-file [-s symbol-file]\n"); + printf(" [output-file] [-l#]\n"); + printf(" -p data-file [output-file]\n"); + printf(" -c\n"); + //printf(" -u\n"); + printf(" -v\n"); + printf(" -help\n"); + printf("\n"); + printf("Mandatory option to choose:\n"); + printf(" -m Build project for analysis.\n"); + printf(" -i Instrument project.\n"); + printf(" -a Analyze report file.\n"); + //printf(" -u Create listing & map files.\n"); + printf(" -c Clear AnalyzeTool changes and temporary files.\n"); + printf(" -p Parse trace file.\n"); + printf(" -help Show full help including syntax examples.\n"); + printf("\n"); + + printf("Optional options:\n"); + printf(" mmp-file Specifies one of the component from bld.inf which is used.\n"); + printf(" target-name Specifies the target name of binary to which create\n"); + printf(" analyze report.\n"); + printf(" mode Logging mode (trace or S60), default trace.\n"); + printf(" data-file Specifies the user defined data file name (50 chars max).\n"); + printf(" build Build target (udeb or urel), default udeb.\n"); + printf(" output-file Specifies the results data file name.\n"); + printf(" -l Logging level of analyze report(0,1,2,3), default 3.\n"); + printf(" -variant Specifies Symbian binary variant to be used.\n"); + printf(" variant-name Specifies the variant name to be used.\n"); + printf(" -s Specifies rom symbol file be used in analyze.\n"); + printf(" symbol-file Full path to rom symbol file used in analyze.\n"); + printf(" -sbs2 Use Symbian Build System v.2.\n"); + printf(" -winscw Build project for emulator (winscw platform).\n"); + printf(" -v Print version info.\n"); + */ +} + +void print_syntax_examples( void ) +{ +//Helper line showing width of 80 chars. +//80cout<< "12345678901234567890123456789012345678901234567890123456789012345678901234567890"; + cout<< endl; + cout<< "Building syntax examples:" << endl; + cout<< "Cmd Description" << endl; + + cout<< "atool -e abld build armv5 udeb" << endl; + cout<< " Hooks every component from bld.inf. Using external data gathering," << endl; + cout<< " udeb build type and armv5 platform." << endl; + + cout<< "atool -mi -acs 5 sbs -c winscw_udeb" << endl; + cout<< " Hooks every component from bld.inf. Using Symbian Build System v.2" << endl; + cout<< " Using monitored internal data gathering, call stack size of 5" << endl; + cout<< " in allocations, udeb build type and winscw platform." << endl; + + cout<< "atool -me abld build armv5 udeb foobar" << endl; + cout<< " Hooks only foobar.mmp component from bld.inf. Using monitored" << endl; + cout<< " external data gathering, udeb build type and armv5 platform." << endl; + + cout<< "atool -e -acs 0 -fcs 0 abld build armv5.default udeb" << endl; + cout<< " Hooks every component from bld.inf. Using default binary variant," << endl; + cout<< " external data gathering, 0 sized callstacks in allocation(s)/free(s)," << endl; + cout<< " udeb build type and armv5 platform." << endl; + + cout<< "atool -e sbs -b bld.inf -c armv5_udeb" << endl; + cout<< " Hooks every component from bld.inf. Using Symbian Build System v.2" << endl; + cout<< " , external data gathering, udeb build type and armv5 platform." << endl; + + cout<< "atool -me sbs -s system.xml --config=winscw_udeb" << endl; + cout<< " Hooks every layer defined in system.xml system model. Using Symbian Build" << endl; + cout<< " System v.2, external data gathering, udeb build type and winscw platform." << endl; + + cout<< endl; + cout<< "Instrumenting syntax examples:" << endl; + cout<< "Cmd Description" << endl; + cout<< "atool -e -nobuild abld build winscw udeb" << endl; + cout<< " Instruments every component from bld.inf. Using external data gathering,"<dwFileVersionMS); + *minorVersion = LOWORD(pFileInfo->dwFileVersionMS); + *buildNumber = HIWORD(pFileInfo->dwFileVersionLS); + *revisionNumber = LOWORD(pFileInfo->dwFileVersionLS); + return 1; + } + free (lpData); + return 0; +} + +//EOF diff -r d27dfa8884ad -r da2cedce4920 analyzetool/dynamicmemoryhook/bwins/atoolmemoryhooku.def --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/dynamicmemoryhook/bwins/atoolmemoryhooku.def Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,10 @@ +EXPORTS + ?Alloc@RAnalyzeToolAllocator@@UAEPAXH@Z @ 1 NONAME ; void * RAnalyzeToolAllocator::Alloc(int) + ?Alloc@RAnalyzeToolMainAllocator@@UAEPAXH@Z @ 2 NONAME ; void * RAnalyzeToolMainAllocator::Alloc(int) + ?Exit@CustomUser@@SAXH@Z @ 3 NONAME ; void CustomUser::Exit(int) + ?InstallAllocator@CustomUser@@CAAAVRAllocator@@HABV?$TBuf@$0BAA@@@KKKK@Z @ 4 NONAME ; class RAllocator & CustomUser::InstallAllocator(int, class TBuf<256> const &, unsigned long, unsigned long, unsigned long, unsigned long) + ?Panic@CustomUser@@SAXABVTDesC16@@H@Z @ 5 NONAME ; void CustomUser::Panic(class TDesC16 const &, int) + ?SetCritical@CustomUser@@SAHW4TCritical@User@@@Z @ 6 NONAME ; int CustomUser::SetCritical(enum User::TCritical) + ?SetProcessCritical@CustomUser@@SAHW4TCritical@User@@@Z @ 7 NONAME ; int CustomUser::SetProcessCritical(enum User::TCritical) + ?SetupThreadHeap@CustomUser@@SAHHAAUSStdEpocThreadCreateInfo@@ABV?$TBuf@$0BAA@@@KKABV?$TBuf@$0BE@@@KKV?$TRefByValue@$$CBVTDesC16@@@@ZZ @ 8 NONAME ; int CustomUser::SetupThreadHeap(int, struct SStdEpocThreadCreateInfo &, class TBuf<256> const &, unsigned long, unsigned long, class TBuf<20> const &, unsigned long, unsigned long, class TRefByValue, ...) + diff -r d27dfa8884ad -r da2cedce4920 analyzetool/dynamicmemoryhook/eabi/atoolmemoryhooku.def --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/dynamicmemoryhook/eabi/atoolmemoryhooku.def Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,16 @@ +EXPORTS + _ZN10CustomUser11SetCriticalEN4User9TCriticalE @ 1 NONAME + _ZN10CustomUser15SetupThreadHeapEiR24SStdEpocThreadCreateInfoRK4TBufILi256EEmmRKS2_ILi20EEmm11TRefByValueIK7TDesC16Ez @ 2 NONAME + _ZN10CustomUser16InstallAllocatorEiRK4TBufILi256EEmmmm @ 3 NONAME + _ZN10CustomUser18SetProcessCriticalEN4User9TCriticalE @ 4 NONAME + _ZN10CustomUser4ExitEi @ 5 NONAME + _ZN10CustomUser5PanicERK7TDesC16i @ 6 NONAME + _ZTI20CLibraryEventHandler @ 7 NONAME ; ## + _ZTI21RAnalyzeToolAllocator @ 8 NONAME ; ## + _ZTI25RAnalyzeToolMainAllocator @ 9 NONAME ; ## + _ZTI27RAnalyzeToolMemoryAllocator @ 10 NONAME ; ## + _ZTV20CLibraryEventHandler @ 11 NONAME ; ## + _ZTV21RAnalyzeToolAllocator @ 12 NONAME ; ## + _ZTV25RAnalyzeToolMainAllocator @ 13 NONAME ; ## + _ZTV27RAnalyzeToolMemoryAllocator @ 14 NONAME ; ## + diff -r d27dfa8884ad -r da2cedce4920 analyzetool/dynamicmemoryhook/group/atoolmemoryhook.mmp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/dynamicmemoryhook/group/atoolmemoryhook.mmp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,68 @@ +/* +* 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: The .mmp file for AToolMemoryHook. +* +*/ + +#include +#include "../../symbian_version.hrh" + +TARGET atoolmemoryhook.dll +TARGETTYPE dll +UID 0x1000008d 0x2001242F +CAPABILITY ALL -TCB + +#if ( SYMBIAN_VERSION_SUPPORT >= SYMBIAN_3 ) +EPOCALLOWDLLDATA +#endif + +SMPSAFE + +SOURCEPATH ../src + +SOURCE analyzetooleventhandler.cpp +SOURCE codeblock.cpp +SOURCE threadstack.cpp +SOURCE customuser.cpp +SOURCE analyzetoolmemoryallocator.cpp +SOURCE analyzetoolmainallocator.cpp +SOURCE analyzetoolallocator.cpp +SOURCE analyzetoolfastlog.cpp + +SOURCEPATH ../../storageserver/server/src +SOURCE atdriveinfo.cpp + +USERINCLUDE ../inc +USERINCLUDE ../../inc +USERINCLUDE ../../storageserver/inc +USERINCLUDE ../../storageserver/server/inc + +#ifdef WINSCW +APP_LAYER_SYSTEMINCLUDE +#endif + +OS_LAYER_SYSTEMINCLUDE + +LIBRARY efsrv.lib +LIBRARY euser.lib +LIBRARY atoolstorageserverclnt.lib +LIBRARY flogger.lib +LIBRARY charconv.lib +LIBRARY platformenv.lib + +#if ( SYMBIAN_VERSION_SUPPORT >= SYMBIAN_3 ) +MACRO USE_CLEANER_DLL +#endif + +// End of File diff -r d27dfa8884ad -r da2cedce4920 analyzetool/dynamicmemoryhook/group/bld.inf --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/dynamicmemoryhook/group/bld.inf Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,26 @@ +/* +* 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: +* +*/ + +PRJ_PLATFORMS +ARMV5 WINSCW + +PRJ_MMPFILES +atoolmemoryhook.mmp + +PRJ_TESTMMPFILES +../internal/tsrc/group/analyzetoolmemoryhooktest.mmp + diff -r d27dfa8884ad -r da2cedce4920 analyzetool/dynamicmemoryhook/inc/analyzetoolallocator.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/dynamicmemoryhook/inc/analyzetoolallocator.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,247 @@ +/* +* 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: Declaration of the class RAnalyzeToolAllocator. +* +*/ + + +#ifndef ANALYZETOOLALLOCATOR_H +#define ANALYZETOOLALLOCATOR_H + +// INCLUDES +#include +#include "codeblock.h" +#include "threadstack.h" +#include "analyzetoolmemoryallocator.h" +#include +#include +#include + +// CLASS DECLARATION + +/** +* Class which overloads the RAlloctor functions and provides access to +* the overloaded functions +*/ +class RAnalyzeToolAllocator : public RAnalyzeToolMemoryAllocator + { + + public: + + /** + * C++ default constructor. + * @param aNotFirst Is this first thread using this heap + * @param aStorageServer A reference to the + * RATStorageServer which is + * used to store kernel events + * @param aCodeblocks A reference to array of code segments + * @param aMutex A reference to mutex for schedule access to the + * shared resources + * @param aProcessId A reference to the observed process id + * @param aAnalyzeTool Reference to device driver + * @param aStorageServerOpen Variable to check if Storage server is connected + * @param aLogOption The logging option for storage server + * @param aAllocCallStackSize Max number of stored callstack items when memory allocated + * @param aFreeCallStackSize Max number of stored callstack items when memory freed + */ + RAnalyzeToolAllocator( TBool aNotFirst, + RATStorageServer& aStorageServer, + RArray& aCodeblocks, + RMutex& aMutex, + TUint aProcessId, + RAnalyzeTool& aAnalyzeTool, + TBool aStorageServerOpen, + TUint32 aLogOption, + TUint32 aAllocCallStackSize, + TUint32 aFreeCallStackSize ); + /** + * Destructor. + */ + ~RAnalyzeToolAllocator(); + + /** + * Allocates a cell of specified size from the heap. + * @param aSize The size of the cell to be allocated from the heap. + * @return TAny* A pointer to the allocated cell. + */ + TAny* Alloc( TInt aSize ); + + /** + * Frees the specified cell and returns it to the heap. + * @param aPtr A pointer to a cell to be freed. + */ + void Free( TAny* aPtr ); + + /** + * Increases or decreases the size of an existing cell. + * @param aPtr A pointer to the cell to be reallocated. + * @param aSize The new size of the cell. This may be bigger + * or smaller than the size of the original cell. + * @param aMode Flags controlling the reallocation. + * @return TAny* A pointer to the reallocated cell. This may be the + * same as the original pointer supplied through aCell. + */ + //lint --e{1735} suppress "Virtual function has default parameter" + TAny* ReAlloc( TAny* aPtr, TInt aSize, TInt aMode = 0 ); + + /** + * Gets the length of the available space in the specified + * allocated cell. + * @param aCell A pointer to the allocated cell. + * @return TInt The length of the available space in the allocated cell. + */ + TInt AllocLen( const TAny* aCell ) const; + + #ifndef __KERNEL_MODE__ + + /** + * Opens this heap for shared access. Opening the heap increases + * the heap's access count by one. + */ + TInt Open(); + + /** + * Closes this shared heap. Closing the heap decreases the heap's + * access count by one. + */ + void Close(); + + /** + * The function frees excess committed space from the top of the heap. + * The size of the heap is never reduced below the minimum size + * specified during creation of the heap. + * @return TInt The space reclaimed. If no space can be reclaimed, + then this value is zero. + */ + TInt Compress(); + + /** + * Frees all allocated cells on this heap. + */ + void Reset(); + + /** + * Gets the number of cells allocated on this heap, and + * the total space allocated to them. + * @param aTotalAllocSize On return, contains the total + * space allocated to the cells. + * @return TInt The number of cells allocated on this heap. + */ + TInt AllocSize( TInt& aTotalAllocSize ) const; + + /** + * Gets the total free space currently available on the heap and the + * space available in the largest free block. The space available + * represents the total space which can be allocated. Note that + * compressing the heap may reduce the total free space available + * and the space available in the largest free block. + * @param aBiggestBlock On return, contains the space available + * in the largest free block on the heap. + + * @return TInt The total free space currently available on the heap. + + */ + TInt Available( TInt& aBiggestBlock ) const; + + #endif + + /** + * Invocates specified debug funtionality. + * @param aFunc The debug function + * @param a1 Debug function specific paramenter. + * @param a2 Debug function specific paramenter. + * @return TInt Returns KErrNone, if successful otherwise one + * of the other system-wide error codes. + */ + //lint --e{1735} suppress "Virtual function has default parameter" + TInt DebugFunction( TInt aFunc, TAny* a1 = NULL, TAny* a2 = NULL ); + + protected: + + /** + * Extension function + * @param aExtensionId The extension id + * @param a0 Extension specific paramenter. + * @param a1 Extension specific paramenter. + * @return TInt Returns KErrNone, if successful otherwise one + * of the other system-wide error codes. + */ + TInt Extension_( TUint aExtensionId, TAny*& a0, TAny* a1 ); + + public: // from RAnalyzeToolMemoryAllocator + + /** + * Installs the RTraceAllocator allocator + */ + void Uninstall(); + + /** + * Shares the heap + */ + void ShareHeap(); + + private: + + /** + * Find the current thread which is using the heap + * @param aStackStart A reference where the stack start is stored + * @return TBool ETrue if a thread can be found, EFalse otherwise + */ + TBool FindCurrentThreadStack( TUint32& aStackStart ); + + private: + + /* Handle to the storage server*/ + RATStorageServer& iStorageServer; + + /* A reference to codeblocks of the observed process */ + RArray& iCodeblocks; + + /* The mutex for serializing access to the shared resources */ + RMutex& iMutex; + + /* The process id */ + TUint iProcessId; + + /* Array for storing the callstack */ + TFixedArray iCallStack; + + /* Array for storing the reallocation callstack */ + TFixedArray iReCallStack; + + /* Array for storing the reallocation callstack */ + TFixedArray iFreeCallStack; + + /* Array of threads using this heap */ + RArray iThreadArray; + + RAnalyzeTool& iAnalyzeTool; + + /* A flag for indicating that the RATStorageServer is open */ + TBool iStorageServerOpen; + + /* Log option */ + TUint32 iLogOption; + + /* Max items on stored call stack when memory allocated */ + TUint32 iAllocMaxCallStack; + + /* Max items on stored call stack when memory freed */ + TUint32 iFreeMaxCallStack; + + }; + +#endif // ANALYZETOOLALLOCATOR_H + +// End of File diff -r d27dfa8884ad -r da2cedce4920 analyzetool/dynamicmemoryhook/inc/analyzetooleventhandler.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/dynamicmemoryhook/inc/analyzetooleventhandler.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,122 @@ +/* +* 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: Declaration of the class CLibraryEventHandler. +* +*/ + + +#ifndef ANALYZETOOLEVENTHANDLER_H +#define ANALYZETOOLEVENTHANDLER_H + +// INCLUDES +#include +#include "codeblock.h" +#include +#include + +// FORWARD DECLARATIONS +class MAnalyzeToolEventhandlerNotifier; + +// CLASS DECLARATION + +/** +* Class for receiving library load/unlaod events from the kernel +*/ +class CLibraryEventHandler : public CActive + { + + public: + + /** + * C++ default constructor. + * @param aAnalyzeTool A reference to the RAnalyzeTool + which is used to observe kernel events + * @param aCodeblocks A reference to array of code segments + * @param aStorageServer A reference to the + * RATStorageServer which is + * used to store kernel events + * @param aProcessId A reference to the observed process id + * @param aMutex A reference to mutex to schedule access to the + * shared resources + * @param aNotifier A reference to notifier object which is used to + * inform killed threads + * @param aLogOption Current used log option on allocator. + */ + CLibraryEventHandler( RAnalyzeTool& aAnalyzeTool, + RArray& aCodeblocks, + RATStorageServer& aStorageServer, + TUint aProcessId, + RMutex& aMutex, + MAnalyzeToolEventhandlerNotifier& aNotifier, + TUint32 aLogOption ); + + /** + * Destructor. + */ + ~CLibraryEventHandler(); + + /* Start receiving events from the kernel */ + void Start(); + + /** + * Returns eventhandler's state. + * @return TBool ETrue if eventhandler is started, EFalse otherwise + */ + TBool IsStarted(); + + protected: // Functions from base classes + + /** + * Process active object's task + */ + void RunL(); + + /** + * Cancels active object's task + */ + void DoCancel(); + + private: // Member variables + + /* Handle to the analyze tool device driver*/ + RAnalyzeTool& iAnalyzeTool; + + /* A reference to codeblocks of the observed process */ + RArray& iCodeblocks; + + /* Handle to the storage server*/ + RATStorageServer& iStorageServer; + + /* The observered process id */ + TUint iProcessId; + + /* The library info */ + TLibraryEventInfo iLibraryInfo; + + /* The mutex for serializing access to the shared resources */ + RMutex& iMutex; + + /* Inform if handler is started */ + TBool iStarted; + + /* A reference to event handler notifier */ + MAnalyzeToolEventhandlerNotifier& iNotifier; + + /* Current used log option */ + TUint32 iLogOption; + }; + +#endif // ANALYZETOOLEVENTHANDLER_H + +// End of File diff -r d27dfa8884ad -r da2cedce4920 analyzetool/dynamicmemoryhook/inc/analyzetooleventhandlernotifier.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/dynamicmemoryhook/inc/analyzetooleventhandlernotifier.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,45 @@ +/* +* 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: Declaration of the class MAnalyzeToolEventhandlerNotifier +* +*/ + + +#ifndef ANALYZETOOLEVENTHANDLERNOTIFIER_H +#define ANALYZETOOLEVENTHANDLERNOTIFIER_H + +// INCLUDES +#include + +// CLASS DECLARATION + +/** +* MAnalyzeToolEventhandlerNotifier class +* An interface class for informing killed thread. +*/ +class MAnalyzeToolEventhandlerNotifier + { + public: // New functions + + /** + * Inform when thread killed. + * @param aThreadId - Killed thread Id. + */ + virtual void RemoveKilledThread( const TUint aThreadId ) = 0; + + }; + +#endif // ANALYZETOOLEVENTHANDLERNOTIFIER_H + +// End of File diff -r d27dfa8884ad -r da2cedce4920 analyzetool/dynamicmemoryhook/inc/analyzetoolfastlog.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/dynamicmemoryhook/inc/analyzetoolfastlog.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,96 @@ +/* +* 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: +* +*/ + + +#ifndef __ANALYZETOOLFASTLOG_H__ +#define __ANALYZETOOLFASTLOG_H__ + +// INCLUDES +#include +#include +#include + +// Function prototypes. + +/** + * TBD + * @param aProcessName The name of the new process started. The length of this + * descriptor must not be greater than KMaxProcessName. + * @param aProcessId The ID of the process started. + * @param aIsDebug Determines whether a binary is UDEB or UREL + * @return KErrNone. +*/ +GLREF_C TInt ATFastLogProcessStarted( const TDesC8& aProcessName, + TUint aProcessId, + TUint32 aIsDebug ); + +/** + * TBD + * @param aProcessId The ID number of the process ended. + * @param aHandleLeakCount Number of handles open. + * @return KErrNone, if successful; otherwise one of the other + * system-wide error codes. + */ +GLREF_C TInt ATFastLogProcessEnded( TUint aProcessId, + TUint aHandleLeakCount ); + +/** + * TBD + * @param aProcessId The ID number of the process ended. + * @param aDllName The name of the new DLL loaded. The length of this descriptor + * must not be greater than KMaxLibraryName. + * @param aStartAddress The start address of the DLL loaded. + * @param aEndAddress The end address of the DLL loaded. + * @return KErrNone. +*/ +GLREF_C TInt ATFastLogDllLoaded( TUint aProcessId, const TDesC8& aDllName, TUint32 aStartAddress, + TUint32 aEndAddress ); + +/** + * TBD + * @param aProcessId The ID number of the process ended. + * @param aDllName The name of the DLL to be unloaded. The length of this + * descriptor must not be greater than KMaxLibraryName. + * @param aStartAddress The start address of the DLL to be unloaded. + * @param aEndAddress The end address of the DLL to be unloaded. + * @return KErrNone. +*/ +GLREF_C TInt ATFastLogDllUnloaded( TUint aProcessId, const TDesC8& aDllName, TUint32 aStartAddress, + TUint32 aEndAddress ); + +/** + * TBD + * @param aProcessId The ID number of the process ended. + * @param aMemAddress The memory location where memory has been allocated. + * @param aCallstack An array including the current call stack. + * @param aSize The size of the newly allocated memory chunk. + * @return KErrNone. +*/ +GLREF_C TInt ATFastLogMemoryAllocated( TUint aProcessId, TUint32 aMemAddress, + TFixedArray& aCallstack, + TInt aSize ); + +/** + * TBD + * @param aProcessId The ID number of the process ended. + * @param aMemAddress The memory location where memory has been deallocated. + * @param aFreeCallstack An array including the current call stack. + * @return KErrNone. +*/ +GLREF_C TInt ATFastLogMemoryFreed( TUint aProcessId, TUint32 aMemAddress, + TFixedArray& aFreeCallstack ); +#endif diff -r d27dfa8884ad -r da2cedce4920 analyzetool/dynamicmemoryhook/inc/analyzetoolmainallocator.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/dynamicmemoryhook/inc/analyzetoolmainallocator.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,329 @@ +/* +* 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: Declaration of the class RAnalyzeToolMainAllocator. +* +*/ + + +#ifndef ANALYZETOOLMAINALLOCATOR_H +#define ANALYZETOOLMAINALLOCATOR_H + +// INCLUDES +#include +#include "codeblock.h" +#include +#include +#include +#include "analyzetoolmemoryallocator.h" +#include "analyzetooleventhandlernotifier.h" + +// FORWARD DECLARATIONS +class CLibraryEventHandler; + +// CLASS DECLARATION + +/** +* Class which overloads the RAlloctor functions and provides access to +* the overloaded functions +*/ +class RAnalyzeToolMainAllocator : public RAnalyzeToolMemoryAllocator, + public MAnalyzeToolEventhandlerNotifier + { + + public: + + /** + * C++ default constructor. + * @param aNotFirst Is this first thread using this heap + * @param aFileName The name of the log file + * @param aLogOption The logging option for storage server + * @param aIsDebug Determines whether a binary is UDEB or UREL + * @param aAllocCallStackSize Max number of stored callstack items when memory allocated + * @param aFreeCallStackSize Max number of stored callstack items when memory freed + */ + RAnalyzeToolMainAllocator( TBool aNotFirst, + const TFileName aFileName, + TUint32 aLogOption, TUint32 aIsDebug, + TUint32 aAllocCallStackSize, + TUint32 aFreeCallStackSize ); + + /** + * Destructor. + */ + ~RAnalyzeToolMainAllocator(); + + /** + * Allocates a cell of specified size from the heap. + * @param aSize The size of the cell to be allocated from the heap. + * @return TAny* A pointer to the allocated cell. + */ + TAny* Alloc( TInt aSize ); + + /** + * Frees the specified cell and returns it to the heap. + * @param aPtr A pointer to a cell to be freed. + */ + void Free( TAny* aPtr ); + + /** + * Increases or decreases the size of an existing cell. + * @param aPtr A pointer to the cell to be reallocated. + * @param aSize The new size of the cell. This may be bigger + * or smaller than the size of the original cell. + * @param aMode Flags controlling the reallocation. + * @return TAny* A pointer to the reallocated cell. This may be the + * same as the original pointer supplied through aCell. + */ + TAny* ReAlloc( TAny* aPtr, TInt aSize, TInt aMode = 0 ); + + /** + * Gets the length of the available space in the specified + * allocated cell. + * @param aCell A pointer to the allocated cell. + * @return TInt The length of the available space in the allocated cell. + */ + TInt AllocLen(const TAny* aCell) const; + + #ifndef __KERNEL_MODE__ + + /** + * Opens this heap for shared access. Opening the heap increases + * the heap's access count by one. + */ + TInt Open(); + + /** + * Closes this shared heap. Closing the heap decreases the heap's + * access count by one. + */ + void Close(); + + /** + * The function frees excess committed space from the top of the heap. + * The size of the heap is never reduced below the minimum size + * specified during creation of the heap. + * @return TInt The space reclaimed. If no space can be reclaimed, + then this value is zero. + */ + TInt Compress(); + + /** + * Frees all allocated cells on this heap. + */ + void Reset(); + + /** + * Gets the number of cells allocated on this heap, and + * the total space allocated to them. + * @param aTotalAllocSize On return, contains the total + * space allocated to the cells. + * @return TInt The number of cells allocated on this heap. + */ + TInt AllocSize( TInt& aTotalAllocSize ) const; + + /** + * Gets the total free space currently available on the heap and the + * space available in the largest free block. The space available + * represents the total space which can be allocated. Note that + * compressing the heap may reduce the total free space available + * and the space available in the largest free block. + * @param aBiggestBlock On return, contains the space available + * in the largest free block on the heap. + + * @return TInt The total free space currently available on the heap. + + */ + TInt Available( TInt& aBiggestBlock ) const; + + #endif + + /** + * Invocates specified debug funtionality. + * @param aFunc The debug function + * @param a1 Debug function specific paramenter. + * @param a2 Debug function specific paramenter. + * @return TInt Returns KErrNone, if successful otherwise one + * of the other system-wide error codes. + */ + TInt DebugFunction( TInt aFunc, TAny* a1 = NULL, TAny* a2 = NULL ); + + // From MAnalyzeToolEventhandlerNotifier + + /** + * Remove killed thread from threads array. + * @param aThreadId - Thread Id + */ + void RemoveKilledThread( const TUint aThreadId ); + + protected: + + /** + * Extension function + * @param aExtensionId The extension id + * @param a0 Extension specific paramenter. + * @param a1 Extension specific paramenter. + * @return TInt Returns KErrNone, if successful otherwise one + * of the other system-wide error codes. + */ + TInt Extension_( TUint aExtensionId, TAny*& a0, TAny* a1 ); + + public: // from RAnalyzeToolMemoryAllocator + + /** + * Installs the RTraceAllocator allocator + */ + void Uninstall(); + + /** + * Shares the heap + */ + void ShareHeap(); + + public: // inlines + + /** + * Acquires the open RATStorageServer handle + * @return RATStorageServer& The open RATStorageServer handle + */ + inline RATStorageServer& StorageServer(); + + /** + * Acquires the codeblocks of the process + * @return RArray& The process codeblocks + */ + inline RArray& Codeblocks(); + + /** + * Acquires the mutex used to access shared objects + * @return RMutex& A reference to open mutex + */ + inline RMutex& Mutex(); + + /** + * Acquires the current process id + * @return TInt The process id + */ + inline TInt ProcessId(); + + /** + * Acquires the logical channel handle + * @return RAnalyzeTool A reference to logical channel + */ + inline RAnalyzeTool& AnalyzeTool(); + + /** + * Acquires information if storage server is open + * @return TBool iStorageServerOpen + */ + inline TBool StorageServerOpen(); + + /** + * Acquires the log option type + * @return TUint32 iLogOption + */ + inline TUint32 LogOption(); + + /** + * Acquires the max size of call stack when memory allocated + * @return TUint32 iAllocMaxCallStack + */ + inline TUint32 AllocMaxCallStack(); + + /** + * Acquires the max size of call stack when memory freed + * @return TUint32 iFreeMaxCallStack + */ + inline TUint32 FreeMaxCallStack(); + + private: // private functions + + /** + * Log the process initial information + * @param aFileName The name of the log file + * @param aLogOption The logging option for storage serve + * @param aIsDebug Determines whether a binary is UDEB or UREL + */ + void LogProcessInformation( const TFileName aFileName, TUint32 aLogOption, + TUint32 aIsDebug ); + + /** + * Find the current thread which is using the heap + * @param aStackStart A reference where the stack start is stored + * @return TBool ETrue if a thread can be found, EFalse otherwise + */ + TBool FindCurrentThreadStack( TUint32& aStackStart ); + + /** + * Installs the eventhandler, if possible + */ + void InstallEventHandler(); + + private: // member variables + + /* Handle to the RATStorageServer */ + RATStorageServer iStorageServer; + + /* Handle to the RAnalyzeTool */ + RAnalyzeTool iAnalyzeTool; + + /* A flag for indicating that the RAnalyzeTool is open */ + TBool iAnalyzeToolOpen; + + /* A flag for indicating that the device driver is loaded */ + TBool iDeviceDriverLoaded; + + /* The codeblocks of the process */ + RArray iCodeblocks; + + /* The handler for kerner events */ + CLibraryEventHandler* iEventHandler; + + /* The mutex for serializing access to the shared resources */ + mutable RMutex iMutex; + + /* Array for storing the callstack */ + TFixedArray iCallStack; + + /* Array for storing the reallocation callstack */ + TFixedArray iReCallStack; + + /* Array for storing the reallocation callstack */ + TFixedArray iFreeCallStack; + + /* Array of threads using this heap */ + RArray iThreadArray; + + /* A flag for indicating that the RATStorageServer is open */ + TBool iStorageServerOpen; + + /* Log option */ + TUint32 iLogOption; + + /* The process id */ + TUint iProcessId; + + /* Max items on stored call stack when memory allocated */ + TUint32 iAllocMaxCallStack; + + /* Max items on stored call stack when memory freed */ + TUint32 iFreeMaxCallStack; + + }; + +// INLINES +#include "analyzetoolmainallocator.inl" + +#endif // ANALYZETOOLMAINALLOCATOR_H + +// End of File diff -r d27dfa8884ad -r da2cedce4920 analyzetool/dynamicmemoryhook/inc/analyzetoolmainallocator.inl --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/dynamicmemoryhook/inc/analyzetoolmainallocator.inl Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,109 @@ +/* +* 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: Definition for the inline functions of RAnalyzeToolMainAllocator. +* +*/ + + +#include "analyzetoolmemoryallocator.h" + +// ----------------------------------------------------------------------------- +// RAnalyzeToolMainAllocator::StorageServer() +// Acquires reference to open RATStorageServer +// ----------------------------------------------------------------------------- +// +inline RATStorageServer& RAnalyzeToolMainAllocator::StorageServer() + { + return iStorageServer; + } + +// ----------------------------------------------------------------------------- +// RAnalyzeToolMainAllocator::Codeblocks() +// Acquires reference to process used codeblocks +// ----------------------------------------------------------------------------- +// +inline RArray& RAnalyzeToolMainAllocator::Codeblocks() + { + return iCodeblocks; + } + +// ----------------------------------------------------------------------------- +// RAnalyzeToolMainAllocator::Mutex() +// Acquires reference to mutex which is used to share resources +// ----------------------------------------------------------------------------- +// +inline RMutex& RAnalyzeToolMainAllocator::Mutex() + { + return iMutex; + } + +// ----------------------------------------------------------------------------- +// RAnalyzeToolMainAllocator::ProcessId() +// Acquires the process id +// ----------------------------------------------------------------------------- +// +inline TInt RAnalyzeToolMainAllocator::ProcessId() + { + return iProcessId; + } + +// ----------------------------------------------------------------------------- +// RAnalyzeToolMainAllocator::AnalyzeTool() +// Acquires the logical channel handle +// ----------------------------------------------------------------------------- +// +inline RAnalyzeTool& RAnalyzeToolMainAllocator::AnalyzeTool() + { + return iAnalyzeTool; + } + +// ----------------------------------------------------------------------------- +// RAnalyzeToolMainAllocator::StorageServerOpen() +// Acquires the iStorageServerOpen variable +// ----------------------------------------------------------------------------- +// +inline TBool RAnalyzeToolMainAllocator::StorageServerOpen() + { + return iStorageServerOpen; + } + +// ----------------------------------------------------------------------------- +// RAnalyzeToolMainAllocator::LogOption() +// Acquires the iLogOption variable +// ----------------------------------------------------------------------------- +// +inline TUint32 RAnalyzeToolMainAllocator::LogOption() + { + return iLogOption; + } + +// ----------------------------------------------------------------------------- +// RAnalyzeToolMainAllocator::AllocMaxCallStack() +// Acquires the iAllocMaxCallStack variable +// ----------------------------------------------------------------------------- +// +inline TUint32 RAnalyzeToolMainAllocator::AllocMaxCallStack() + { + return iAllocMaxCallStack; + } +// ----------------------------------------------------------------------------- +// RAnalyzeToolMainAllocator::FreeMaxCallStack() +// Acquires the iFreeMaxCallStack variable +// ----------------------------------------------------------------------------- +// +inline TUint32 RAnalyzeToolMainAllocator::FreeMaxCallStack() + { + return iFreeMaxCallStack; + } +// End of File diff -r d27dfa8884ad -r da2cedce4920 analyzetool/dynamicmemoryhook/inc/analyzetoolmemoryallocator.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/dynamicmemoryhook/inc/analyzetoolmemoryallocator.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,94 @@ +/* +* 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: Declaration of the class RAnalyzeToolMemoryAllocator. +* +*/ + + +#ifndef ANALYZETOOLMEMORYALLOCATOR_H +#define ANALYZETOOLMEMORYALLOCATOR_H + +// INCLUDES +#include +#include "threadstack.h" +#include "../../symbian_version.hrh" + +// CONSTANTS +#if ( SYMBIAN_VERSION_SUPPORT >= SYMBIAN_3 ) + #ifndef __WINS__ + const TInt KDummyHandle = -1000; + #endif +#endif + +// CLASS DECLARATION + +/** +* Abstract class for basic RAnalyzeToolMemoryAllocator funtions +*/ +class RAnalyzeToolMemoryAllocator : public RAllocator + { + public: + + /** + * C++ default constructor. + * @param aNotFirst Is this first thread using this heap + */ + RAnalyzeToolMemoryAllocator( TBool aNotFirst ); + + /** + * Destructor. + */ + //lint -e{1510} suppress "base class 'RAllocator' has no destructor" + virtual ~RAnalyzeToolMemoryAllocator(); + + /** + * Uninstall the RAnalyzeToolMemoryAllocator + */ + virtual void Uninstall() = 0; + + /** + * Shares the heap for another thread + */ + virtual void ShareHeap() = 0; + + protected: + + /** + * Switch original allocator in use. + * Switches original allocator in use if not already. + */ + void SwitchOriginalAllocator(); + + /** + * Checks is the given address in loaded code memory area. + */ + inline bool IsAddressLoadedCode( TUint32& aAddress ); + + /* The original thread RAllocator */ + RAllocator* iAllocator; + + /* Is this the first thread using this heap */ + TBool iNotFirst; + + /* Memorymodel */ + TUint32 iMemoryModel; + + }; + +// INLINES +#include "analyzetoolmemoryallocator.inl" + +#endif // ANALYZETOOLMEMORYALLOCATOR_H + +// End of File diff -r d27dfa8884ad -r da2cedce4920 analyzetool/dynamicmemoryhook/inc/analyzetoolmemoryallocator.inl --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/dynamicmemoryhook/inc/analyzetoolmemoryallocator.inl Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,54 @@ +/* +* 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: Definition for the inline functions of RAnalyzeToolMemoryAllocator. +* +*/ + + + +#include + +// ----------------------------------------------------------------------------- +// RAnalyzeToolMemoryAllocator::IsAddressLoadedCode() +// Checks is the given address in loaded code memory area. +// ----------------------------------------------------------------------------- +// +inline bool RAnalyzeToolMemoryAllocator::IsAddressLoadedCode( TUint32& aAddress ) + { + // Debug log strings in this function are not used because + // this is called so many times. + /* + * TMemModelAttributes models. + * EMemModelTypeDirect // direct memory model on hardware + * EMemModelTypeMoving=1 // moving memory model on hardware + * EMemModelTypeMultiple=2 // multiple memory model on hardware + * EMemModelTypeEmul=3 // emulation using single host process + * Flexible ? + */ + switch( iMemoryModel ) + { + case EMemModelTypeMultiple: + // Use low & high limits which define rofs loading->rom area + // in multiple memory model. + if ( aAddress < KATMultipleMemoryModelLowLimit + || aAddress > KATMultipleMemoryModelHighLimit ) + return false; + return true; + default: + return true; + } + } + +// End of File + diff -r d27dfa8884ad -r da2cedce4920 analyzetool/dynamicmemoryhook/inc/analyzetoolpanics.pan --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/dynamicmemoryhook/inc/analyzetoolpanics.pan Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,46 @@ +/* +* 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: Panic codes and definition of a panic function for the Memory Hook +* +*/ + + +#ifndef ANALYZETOOLPANICS_PAN_H +#define ANALYZETOOLPANICS_PAN_H + +_LIT( KAnalyzeToolName, "AnalyzeTool" ); + +/** AnalyzeTool application panic codes */ +enum TAnalyzeToolPanics + { + ENoMemory = 1, + EFailedToCreateHeap, + ECantOpenHandle, + ECantLoadDevice, + ECantAppendToTheArray, + ECantFindRightThread, + ECantConnectStorageServer, + ECantShareStorageServer, + ECantCreateMutex, + ECantLoadDeviceDriver, + ECantConnectDeviceDriver + // add further panics here + }; + +inline void AssertPanic(TAnalyzeToolPanics aReason) + { + User::Panic( KAnalyzeToolName, aReason ); + } + +#endif // ANALYZETOOLPANICS_PAN_H diff -r d27dfa8884ad -r da2cedce4920 analyzetool/dynamicmemoryhook/inc/codeblock.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/dynamicmemoryhook/inc/codeblock.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,74 @@ +/* +* 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: Declaration of the class TCodeblock. +* +*/ + + +#ifndef CODEBLOCK_H +#define CODEBLOCK_H + +// INCLUDES +#include + +/** +* Stores information of process loaded code segments +*/ +class TCodeblock + { + + public: // Constructors + + /** + * C++ default constructor. + * @param aRunAddress Start address of the memory block. + * @param aSize The size of the memory block. + * @param aName The name of the library + */ + TCodeblock( TLinAddr aRunAddress, TUint32 aSize, TBuf8& aName ); + + public: // New functions + + /** + * Checks if the given address is in this memory block area + * @param aAddress A address to be checked. + * @return TBool Returns ETrue if the given address is in this + * memory block area, EFalse otherwise + */ + TBool CheckAddress( TUint32 aAddress ); + + /** + * Matches if the given parameters represents this memory block + * @param aName The name of the library + * @return TBool Returns ETrue if the given parameters represents + * this memory block, EFalse otherwise + */ + TBool Match( TBuf8& aName ); + + private: // Member variables + + /* Start address of the memory block */ + TLinAddr iStartAddress; + + /* End address of the memory block */ + TLinAddr iEndAddress; + + /* End address of the memory block */ + TBuf8 iName; + }; + +#endif // CODEBLOCK_H + +// End of File + diff -r d27dfa8884ad -r da2cedce4920 analyzetool/dynamicmemoryhook/inc/customuser.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/dynamicmemoryhook/inc/customuser.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,207 @@ +/* +* 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: Declaration of the class CustomUser containing overloaded User static functions. +* +*/ + + +#ifndef CUSTOMUSER_H +#define CUSTOMUSER_H + +// INCLUDES +#include + +// CONSTANTS +const TInt KATVersionLength = 20; +const TInt KATDefaultLogOption = 0; +const TInt KATDefaultDebug = 1; +const TInt KATDefaultAllocCallStackSize = 40; +const TInt KATDefaultFreeCallStackSize = 0; + +// TYPEDEFS +typedef TBuf TATVersion; + +// Argument list for SetupThreadHeap function parameters. (currently not used) +// When needed, update the argument type directly inside _LIT macro. +_LIT( KATArgumentList, "%i%i" ); //etc. + +// CLASS DECLARATION + +/** +* Class which overloads the User functions and provides access to +* the overloaded functions +*/ +class CustomUser + { + public: // Enumerations + enum TATOptions + { + /** Acquiring the log filename */ + ELogFileName = 1, + /** Acquiring the version number */ + EVersion, + /** Acquiring logging option */ + ELogOption, + /** Acquiring UDEB/UREL information */ + EDebug, + /** Acquiring max allocation call stack size */ + EAllocCallStackSize, + /** Acquiring max free call stack size */ + EFreeCallStackSize + }; + + public: + + /** + * Overloaded version of User::Exit() + * Terminates the current thread, specifying a reason. All child + * threads are terminated and all resources are cleaned up.If the + * current thread is the main thread in a process, the process is + * also terminated. + * @param aReason The reason code. + */ + IMPORT_C static void Exit( TInt aReason ); + + /** + * Overloaded version of User::Panic() + * Panics the current thread, specifying a category name and panic + * number. Keep the length of the category name small; + * a length of 16 is ideal. + * @param aCategory A reference to the descriptor containing the text + * that defines the category for this panic. + * @param aReason The panic number. + */ + IMPORT_C static void Panic( const TDesC& aCategory, TInt aReason ); + + /** + * Overloaded version of UserHeap::SetupThreadHeap() + * Setups the threads heap. + * @param aNotFirst Is this first thread using specified heap + * @param aInfo Specifies the thread heap properties + * @param aFileName The name of the log file + * @param aLogOption The logging option for storage server + * @param aIsDebug Determines whether a binary is UDEB or UREL + * @param aVersion Atool version number + * @param aAllocCallStackSize Max number of stored callstack items when memory allocated + * @param aFreeCallStackSize Max number of stored callstack items when memory freed + * @param aFmt A descriptor containing the format string + * @return TInt KErrNone, if the insertion is successful, otherwise + * one of the system wide error codes. + */ + IMPORT_C static TInt SetupThreadHeap( + TBool aNotFirst, + SStdEpocThreadCreateInfo& aInfo, + const TFileName& aFileName, + TUint32 aLogOption, TUint32 aIsDebug, + const TATVersion& aVersion, + TUint32 aAllocCallStackSize, + TUint32 aFreeCallStackSize, + TRefByValue aFmt, ... ); + + /** + * Overloaded version of UserHeap::SetCritical() + * Sets up or changes the effect that termination of the current + * thread has, either on its owning process, or on the whole system. + * The precise effect of thread termination is defined by the following + * specific values of the TCritical enum: + * ENotCritical + * EProcessCritical + * EProcessPermanent + * ESystemCritical + * ESystemPermanent + * Notes: The enum value EAllThreadsCritical cannot be set using this + * function. It is associated with a process, not a thread, and, if + * appropriate, should be set using User::SetProcessCritical(). + * The states associated with ENotCritical, EProcessCritical, + * EProcessPermanent, ESystemCritical and ESystemPermanent are all + * mutually exclusive, i.e. the thread can only be in one of these + * states at any one time. + * @param aCritical The state to be set. + * @return TInt KErrNone, if successful; KErrArgument, if + * EAllThreadsCritical is passed - this is a state associated with a + * process, and you use User::SetProcessCritical() to set it. + */ + IMPORT_C static TInt SetCritical( User::TCritical aCritical ); + + /** + * Overloaded version of UserHeap::SetCritical() + * Sets up or changes the effect that termination of subsequently + * created threads will have, either on the owning process, + * or on the whole system. It is important to note that we are not + * referring to threads that have already been created, but threads + * that will be created subsequent to a call to this function. + * The precise effect of thread termination is defined by the following + * specific values of the TCritical enum: + * ENotCritical + * EAllThreadsCritical + * ESystemCritical + * ESystemPermanent + * Notes: + * The enum values EProcessCritical and EProcessPermanent cannot be set + * using this function. They are states associated with a thread, not a + * process, and, if appropriate, should be set using + * User::SetCritical(). The states associated with ENotCritical, + * EAllThreadsCritical, ESystemCritical and ESystemPermanent are all + * mutually exclusive, i.e. the process can only be in one of these + * states at any one time. + * @param aCritical The state to be set. + * @return TInt 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. + */ + IMPORT_C static TInt SetProcessCritical( User::TCritical aCritical ); + + private: // Private functions + + /** + * Factory function for creating RAllocator instances. + * @param aNotFirst Is this first thread using specified heap + * @param aLogOption The logging option for storage server + * @param aFileName The name of the logging file + * @param aIsDebug Determines whether a binary is UDEB or UREL + * @param aAllocCallStackSize Max number of stored callstack items when memory allocated + * @param aFreecallStackSize Max number of stored callstack items when memory freed + * @return RAllocator& A reference to created allocator + */ + static RAllocator& InstallAllocator( TBool aNotFirst, + const TFileName& aFileName, + TUint32 aLogOption, TUint32 aIsDebug, + TUint32 aAllocCallStackSize, + TUint32 aFreeCallStackSize ); + + /** + * Check atool version + * @param aVersion - Atool version number. + * @param aToolVersion The atool version number + * @return KErrNone if correct version found, otherwise one of the system wide + * error codes. + */ + static TInt CheckVersion( const TATVersion& aVersion, TDes& aToolVersion ); + + /** + * Function for showing incorrect version information (file or debug channel). + * @param aLogOption The logging option + * @param aFileName The name of the log file + * @param aToolVersion The atool version number + */ + static void ReportIncorrectVersion( const TUint32 aLogOption, + const TFileName& aFileName, + const TDes& aToolVersion ); + + }; + +#endif // CUSTOMUSER_H + +// End of File diff -r d27dfa8884ad -r da2cedce4920 analyzetool/dynamicmemoryhook/inc/threadstack.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/dynamicmemoryhook/inc/threadstack.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,70 @@ +/* +* 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: Declaration of the class TThreadStack. +* +*/ + + +#ifndef THREADSTACK_H +#define THREADSTACK_H + +// INCLUDES +#include + +// CLASS DECLARATION + +/** +* Stores thread id and the start of the thread's callstack +*/ +class TThreadStack + { + public: + + /** + * C++ default constructor. + * @param aId The thread id + * @param aStackStart The start of thread's stack + */ + TThreadStack( TThreadId aId, TUint32 aStackStart ); + + /** + * Checks if this is the current thread and if this is the current + * thread assings value to the given parameter + * @param aStackStart& A reference to stack start + * @return TBool The start of thread's stack + */ + TBool ThreadStackStart( TUint32& aStackStart ); + + /** + * Checks if this the the current thread + * @param aThreadId A thread id + * @return TBool ETrue it this is the current thread, EFalse otherwise + */ + TBool Match( const TUint aThreadId = 0 ); + + private: // Member variables + + /* The id of the thread */ + TThreadId iId; + + /* The start addess of this thread */ + TUint32 iStackStart; + }; + + +#endif // THREADSTACK_H + +// End of File + + diff -r d27dfa8884ad -r da2cedce4920 analyzetool/dynamicmemoryhook/sis/analyzetoolmemoryhook.pkg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/dynamicmemoryhook/sis/analyzetoolmemoryhook.pkg Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,34 @@ +; +; 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: +; + +;Language - standard language definitions +&EN + +; standard SIS file header +#{"AnalyzeToolMemoryHook"},(0xEDF5A8B1),1,8,1 + +;Localised Vendor name +%{"Vendor-EN"} + +;Unique Vendor name +:"Vendor" + +;Supports Series 60 v 3.0 +[0x101F7961], 0, 0, 0, {"Series60ProductID"} + +; 1 File to install +"\epoc32\release\armv5\urel\atoolmemoryhook.dll"-"!:\sys\bin\atoolmemoryhook.dll" +"\epoc32\release\armv5\urel\atoolcleaner.dll" -"!:\sys\bin\atoolcleaner.dll" \ No newline at end of file diff -r d27dfa8884ad -r da2cedce4920 analyzetool/dynamicmemoryhook/src/analyzetoolallocator.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/dynamicmemoryhook/src/analyzetoolallocator.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,1014 @@ +/* +* 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 RAnalyzeToolAllocator. +* +*/ + + +#include "analyzetoolallocator.h" +#include "analyzetoolmemoryallocator.h" +#include "atlog.h" +#include "analyzetoolpanics.pan" +#include "analyzetoolfastlog.h" +#include + +// CONSTANTS + +// Length of the callstack address +const TUint32 KAddressLength = 4; + +// Thread count +const TInt KThreadCount = 1; + +// ----------------------------------------------------------------------------- +// RAnalyzeToolAllocator::RAnalyzeToolAllocator() +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +RAnalyzeToolAllocator::RAnalyzeToolAllocator( TBool aNotFirst, + RATStorageServer& aStorageServer, + RArray& aCodeblocks, + RMutex& aMutex, + TUint aProcessId, + RAnalyzeTool& aAnalyzeTool, + TBool aStorageServerOpen, + TUint32 aLogOption, + TUint32 aAllocCallStackSize, + TUint32 aFreeCallStackSize ) : + RAnalyzeToolMemoryAllocator( aNotFirst ), + iStorageServer( aStorageServer ), + iCodeblocks( aCodeblocks ), + iMutex( aMutex ), + iProcessId( aProcessId ), + iThreadArray( KATMaxCallstackLength ), + iAnalyzeTool( aAnalyzeTool ), + iStorageServerOpen( aStorageServerOpen ), + iLogOption( aLogOption ), + iAllocMaxCallStack( aAllocCallStackSize ), + iFreeMaxCallStack( aFreeCallStackSize ) + { + LOGSTR1( "ATMH RAnalyzeToolAllocator::RAnalyzeToolAllocator()" ); + + // Append thread to array of the users of this allocator + TThreadParamsBuf params; + params().iThreadId = RThread().Id().operator TUint(); + TInt error = iAnalyzeTool.ThreadStack( params ); + if ( KErrNone == error ) + { + LOGSTR2( "ATMH Thread stack address: %x", params().iStackAddress ); + LOGSTR2( "ATMH Thread stack size: %x", params().iStackSize ); + error = iThreadArray.Append( TThreadStack( RThread().Id(), + params().iStackAddress + params().iStackSize ) ); + } + + __ASSERT_ALWAYS( KErrNone == error, AssertPanic( ECantAppendToTheArray ) ); + } + +// ----------------------------------------------------------------------------- +// RAnalyzeToolAllocator::~RAnalyzeToolAllocator() +// Destructor. +// ----------------------------------------------------------------------------- +// +RAnalyzeToolAllocator::~RAnalyzeToolAllocator() + { + LOGSTR1( "ATMH RAnalyzeToolAllocator::~RAnalyzeToolAllocator()" ); + + // Close the thread array + iThreadArray.Close(); + } + +// ----------------------------------------------------------------------------- +// RAnalyzeToolAllocator::Uninstall() +// Uninstalls the current allocator +// ----------------------------------------------------------------------------- +// +void RAnalyzeToolAllocator::Uninstall() + { + LOGSTR1( "ATMH RAnalyzeToolAllocator::Uninstall()" ); + + // Switch back to the original allocator + SwitchOriginalAllocator(); + + // Check if this is shared allocator between threads + if ( iThreadArray.Count() > KThreadCount ) + { + // Close the shared allocator + Close(); + return; + } + +#if ( SYMBIAN_VERSION_SUPPORT >= SYMBIAN_3 ) + #ifndef __WINS__ + // Remove dummy Tls handle + UserSvr::DllFreeTls( KDummyHandle ); + #endif +#endif + + // Since this is the last thread using this allocator it can be deleted + delete this; + } + +#ifdef __WINS__ + +// ----------------------------------------------------------------------------- +// RAnalyzeToolAllocator::Alloc() WINS version +// Allocates a cell of specified size from the heap. +// ----------------------------------------------------------------------------- +// +UEXPORT_C TAny* RAnalyzeToolAllocator::Alloc( TInt aSize ) + { + LOGSTR1( "ATMH RAnalyzeToolAllocator::Alloc()" ); + + // Acquire the mutex + iMutex.Wait(); + + // Alloc memory from the original allocator + TAny* p = iAllocator->Alloc( aSize ); + + LOGSTR3( "ATMH RAnalyzeToolAllocator::Alloc() - aSize: %i, address: %x", + aSize, (TUint32) p ); + + // Don't collect call stack and log data + // if storage server not open or logging mode not fast. + if ( iStorageServerOpen || iLogOption == EATLogToTraceFast ) + { + // Reset the callstack + iCallStack.Reset(); + + // Find the current thread callstack start address + TUint32 stackstart( 0 ); + TBool found( FindCurrentThreadStack( stackstart ) ); + LOGSTR3( "ATMH > stackstart: %x , found = %i", stackstart, found ); + + TUint32 _sp; + __asm + { + mov [_sp], esp + } + + // Get codeblocks count + TInt blocksCount( iCodeblocks.Count() ); + TInt error( KErrNone ); + TUint arrayCounter = 0; + + for ( TUint32 i = _sp; i < stackstart; i = i + KAddressLength )//lint !e1055 !e526 !e628 !e348 + { + TUint32 addr = (TUint32) *( (TUint32*) i ); + if ( ! IsAddressLoadedCode( addr ) ) + continue; + for ( TInt j = 0; j < blocksCount; j++ ) + { + if ( iCodeblocks[j].CheckAddress( addr ) ) + { + // To avoid recursive call to ReAlloc specifying granularity + // Add address to the callstack + iCallStack[arrayCounter] = ( addr ); + arrayCounter++; + break; + } + } + if ( arrayCounter == KATMaxCallstackLength || + arrayCounter == iAllocMaxCallStack ) + { + LOGSTR2( "ATMH > Wanted CallStack items ready( %i )", arrayCounter ); + break; + } + } + // Log the memory allocation information + if ( iLogOption == EATLogToTraceFast ) + { + // Using fast mode. + ATFastLogMemoryAllocated( iProcessId, (TUint32) p, iCallStack, aSize ); + } + else + { + // Using storage server. + error = iStorageServer.LogMemoryAllocated( (TUint32) p, + iCallStack, + aSize ); + if ( KErrNone != error ) + { + LOGSTR2( "ATMH LogMemoryAllocated error %i", error ); + switch ( error ) + { + case KErrNoMemory: + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::Alloc() - KErrNoMemory case" ); + if ( iStorageServerOpen ) + { + iStorageServerOpen = EFalse; + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::Alloc() - close iStorageServer" ); + iStorageServer.Close(); + } + break; + } + } + } + } + // Release the mutex + iMutex.Signal(); + + return p; + } +#else + +// ----------------------------------------------------------------------------- +// RAnalyzeToolAllocator::Alloc() ARMV5 version +// Allocates a cell of specified size from the heap. +// ----------------------------------------------------------------------------- +// +TAny* RAnalyzeToolAllocator::Alloc( TInt aSize ) + { + LOGSTR1( "ATMH RAnalyzeToolAllocator::Alloc()" ); + + // Acquire the mutex + iMutex.Wait(); + + // Alloc memory from the original allocator + TAny* p = iAllocator->Alloc( aSize ); + + // Don't collect call stack and log data + // if storage server not open or logging mode not fast. + if ( iStorageServerOpen || iLogOption == EATLogToTraceFast ) + { + // Reset the callstack + iCallStack.Reset(); + + // Find the current thread callstack start address + TUint32 stackstart( 0 ); + TBool found( FindCurrentThreadStack( stackstart ) ); + LOGSTR3( "ATMH > stackstart: %x , found = %i", stackstart, found ); + + // Get codeblocks count + TInt blocksCount( iCodeblocks.Count() ); + TInt error( KErrNone ); + TUint arrayCounter = 0; + + for ( TUint32 i = __current_sp(); i < stackstart; i = i + KAddressLength )//lint !e1055 !e526 !e628 !e348 + { + TUint32 addr = (TUint32) *( (TUint32*) i ); + if ( ! IsAddressLoadedCode( addr ) ) + continue; + for ( TInt j = 0; j < blocksCount; j++ ) + { + if ( iCodeblocks[j].CheckAddress( addr ) ) + { + // To avoid recursive call to ReAlloc specifying granularity + // Add address to the callstack + iCallStack[arrayCounter] = ( addr ); + arrayCounter++; + break; + } + } + if ( arrayCounter == KATMaxCallstackLength || + arrayCounter == iAllocMaxCallStack ) + { + LOGSTR2( "ATMH > Wanted CallStack items ready( %i )", arrayCounter ); + break; + } + } + // Log the memory allocation information + if ( iLogOption == EATLogToTraceFast ) + { + // Fast mode. + ATFastLogMemoryAllocated( iProcessId, (TUint32) p, iCallStack, aSize ); + } + else + { + // Using storage server. + error = iStorageServer.LogMemoryAllocated( (TUint32) p, + iCallStack, + aSize ); + if ( KErrNone != error ) + { + LOGSTR2( "ATMH LogMemoryAllocated error %i", error ); + switch ( error ) + { + case KErrNoMemory: + LOGSTR1( "ATMH RAnalyzeToolAllocator::Alloc() - KErrNoMemory case" ); + if ( iStorageServerOpen ) + { + iStorageServerOpen = EFalse; + LOGSTR1( "ATMH RAnalyzeToolAllocator::Alloc() - close iStorageServer" ); + iStorageServer.Close(); + } + break; + } + } + } + } + + // Release the mutex + iMutex.Signal(); + + // Return the allocatated memory + return p; + } +#endif // __WINS__ + +// ----------------------------------------------------------------------------- +// RAnalyzeToolAllocator::Free() +// Frees the allocated memory +// ----------------------------------------------------------------------------- +// +TAny RAnalyzeToolAllocator::Free( TAny* aPtr ) + { + LOGSTR1( "ATMH RAnalyzeToolAllocator::Free()" ); + + // Acquire the mutex + iMutex.Wait(); + + // Don't collect or log data if storage server not open or logging mode not fast. + if ( iStorageServerOpen || iLogOption == EATLogToTraceFast ) + { + // Reset the callstack + iFreeCallStack.Reset(); + + // Check if trace logging mode because free call stack is not used in other log options. + if ( (iLogOption == EATUseDefault || iLogOption == EATLogToTrace || iLogOption == EATLogToTraceFast ) + && iFreeMaxCallStack > 0 ) + { + // Find the current thread callstack start address + TUint32 stackstart( 0 ); + TBool found( FindCurrentThreadStack( stackstart ) ); + LOGSTR3( "ATMH > stackstart: %x , found = %i", stackstart, found ); + TUint32 _sp; + + #ifdef __WINS__ + __asm + { + mov [_sp], esp + } + #else + _sp = __current_sp(); + #endif + + // Get codeblocks count + TInt blocksCount( iCodeblocks.Count() ); + TUint arrayCounter = 0; + + for ( TUint32 i = _sp; i < stackstart; i = i + KAddressLength )//lint !e1055 !e526 !e628 !e348 + { + TUint32 addr = (TUint32) *( (TUint32*) i ); + if ( ! IsAddressLoadedCode( addr ) ) + continue; + for ( TInt j = 0; j < blocksCount; j++ ) + { + if ( iCodeblocks[j].CheckAddress( addr ) ) + { + // To avoid recursive call to ReAlloc specifying granularity + // Add address to the callstack + iFreeCallStack[arrayCounter] = addr; + arrayCounter++; + break; + } + } + if ( arrayCounter == KATMaxFreeCallstackLength || + arrayCounter == iFreeMaxCallStack ) + { + break; + } + } + LOGSTR2( "ATMH > iFreeCallStack count ( %i )", arrayCounter ); + } + + // Log freed memory. + if ( iLogOption == EATLogToTraceFast ) + { + // Using fast mode. + ATFastLogMemoryFreed( iProcessId, (TUint32) aPtr, iFreeCallStack ); + } + else + { + // Using storage server. + TInt err( iStorageServer.LogMemoryFreed( (TUint32) aPtr, iFreeCallStack ) ); + if ( err != KErrNone ) + { + LOGSTR2( "ATMH > LogMemoryFreed err( %i )", err ); + } + } + } + + // Free the memory using original allocator + iAllocator->Free( aPtr ); + + LOGSTR2( "ATMH RAnalyzeToolAllocator::Free() - aPtr: %x", (TUint32)aPtr ); + + // Release the mutex + iMutex.Signal(); + } + +// ----------------------------------------------------------------------------- +// RAnalyzeToolAllocator::Open() +// Opens this heap for shared access. Opening the heap increases +// the heap's access count by one. +// ----------------------------------------------------------------------------- +// +TInt RAnalyzeToolAllocator::Open() + { + LOGSTR1( "ATMH RAnalyzeToolAllocator::Open()"); + + // Acquire the mutex + iMutex.Wait(); + + // Share the memory using original allocator + TInt error = iAllocator->Open(); + + // If everything is OK add thread to the array which use this allocator + if ( KErrNone == error ) + { + TThreadParamsBuf params; + params().iThreadId = RThread().Id().operator TUint(); + error = iAnalyzeTool.ThreadStack( params ); + + __ASSERT_ALWAYS( KErrNone == error, AssertPanic( ECantAppendToTheArray ) ); + + if ( KErrNone == error ) + { + 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 ) ); + } + } + + // Release the mutex + iMutex.Signal(); + + // Return the error code + return error; + } + +// ----------------------------------------------------------------------------- +// RAnalyzeToolAllocator::Close() +// Closes this shared heap. Closing the heap decreases the heap's +// access count by one. +// ----------------------------------------------------------------------------- +// +void RAnalyzeToolAllocator::Close() + { + LOGSTR1( "ATMH RAnalyzeToolAllocator::Close()" ); + + // Acquire the mutex + iMutex.Wait(); + + // Close the memory using original allocator + iAllocator->Close(); + + TInt count = iThreadArray.Count(); + + // Iterate through array of threads to remove current thread + for ( TInt i = 0; i < count; i++ ) + { + // Check if this is current thread + if ( iThreadArray[ i ].Match() ) + { + // Remove the thread + iThreadArray.Remove( i ); + break; + } + } + + // Release the mutex + iMutex.Signal(); + } + +#ifdef __WINS__ + +// ----------------------------------------------------------------------------- +// RAnalyzeToolAllocator::ReAlloc() +// Increases or decreases the size of an existing cell. +// ----------------------------------------------------------------------------- +// +TAny* RAnalyzeToolAllocator::ReAlloc( TAny* aPtr, TInt aSize, TInt aMode ) + { + LOGSTR1( "ATMH RAnalyzeToolAllocator::ReAlloc()" ); + + // Acquire the mutex + iMutex.Wait(); + + // Realloc the memory using original allocator + TAny* ptr = iAllocator->ReAlloc( aPtr, aSize, aMode ); + + // NULL addresses are not in a process under test + if ( ptr && !( aMode & ENeverMove ) ) + { + LOGSTR3( "ATMH RAnalyzeToolAllocator::ReAlloc() - aPtr: %x, ptr: %x", + (TUint32)aPtr, (TUint32)ptr ); + LOGSTR3( "ATMH RAnalyzeToolAllocator::ReAlloc() - aSize: %i, aMode: %i", + aSize, aMode ); + + // Don't collect or log data if storage server not open or logging mode fast. + if ( iStorageServerOpen || iLogOption == EATLogToTraceFast ) + { + // Reset the callstack + iReCallStack.Reset(); + + // Find the current thread callstack start address + TUint32 stackstart( 0 ); + TBool found( FindCurrentThreadStack( stackstart ) ); + LOGSTR3( "ATMH > stackstart: %x , found = %i", stackstart, found ); + + // Get current sp + TUint32 _sp( 0 ); + __asm + { + mov [_sp], esp + } + + // Get codeblocks count + TInt blocksCount( iCodeblocks.Count() ); + TInt error( KErrNone ); + TUint arrayCounter = 0; + + for ( TUint32 i = _sp; i < stackstart; i = i + KAddressLength )//lint !e1055 !e526 !e628 !e348 + { + TUint32 addr = (TUint32) *( (TUint32*) i ); + if ( ! IsAddressLoadedCode( addr ) ) + continue; + for ( TInt j = 0; j < blocksCount; j++ ) + { + if ( iCodeblocks[j].CheckAddress( addr ) ) + { + // To avoid recursive call to ReAlloc specifying granularity + // Add address to the callstack + iReCallStack[arrayCounter] = addr; + arrayCounter++; + break; + } + } + if ( arrayCounter == KATMaxCallstackLength || + arrayCounter == iAllocMaxCallStack ) + { + LOGSTR2( "ATMH > Wanted CallStack items ready( %i )", arrayCounter ); + break; + } + } + + // No need to report free if the aPtr was NULL + if ( aPtr != NULL ) + { + // Reset the free callstack + iFreeCallStack.Reset(); + + // if trace logging mode(s) we also log call stack in free. + 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 mode. + ATFastLogMemoryAllocated( iProcessId, (TUint32) ptr, iFreeCallStack, aSize); + } + else + { + // Using storage server. + error = iStorageServer.LogMemoryAllocated( (TUint32) ptr, + iReCallStack, + aSize ); + if ( KErrNone != error ) + { + LOGSTR2( "ATMH LogMemoryAllocated ReAlloc error %i", error ); + switch ( error ) + { + case KErrNoMemory: + LOGSTR1( "ATMH RAnalyzeToolAllocator::ReAlloc() - KErrNoMemory case" ); + if ( iStorageServerOpen ) + { + iStorageServerOpen = EFalse; + LOGSTR1( "ATMH RAnalyzeToolAllocator::ReAlloc() - close iStorageServer" ); + iStorageServer.Close(); + } + break; + } + } + } + } + } + + // Release the mutex + iMutex.Signal(); + + // Return pointer to the reallocated cell + return ptr; + } + +#else + +// ----------------------------------------------------------------------------- +// RAnalyzeToolAllocator::ReAlloc() +// Increases or decreases the size of an existing cell. +// ----------------------------------------------------------------------------- +// +TAny* RAnalyzeToolAllocator::ReAlloc( TAny* aPtr, TInt aSize, TInt aMode ) + { + LOGSTR1( "ATMH RAnalyzeToolAllocator::ReAlloc()" ); + + // Acquire the mutex + iMutex.Wait(); + + // Realloc the memory using original allocator + TAny* ptr = iAllocator->ReAlloc( aPtr, aSize, aMode ); + + // NULL addresses are not in a process under test + if ( ptr && !( aMode & ENeverMove ) ) + { + LOGSTR3( "ATMH RAnalyzeToolAllocator::ReAlloc() - aPtr: %x, ptr: %x", + (TUint32)aPtr, (TUint32)ptr ); + LOGSTR3( "ATMH RAnalyzeToolAllocator::ReAlloc() - aSize: %i, aMode: %i", + aSize, aMode ); + + // Don't collect or log data if storage server not open or logging mode fast. + if ( iStorageServerOpen || iLogOption == EATLogToTraceFast ) + { + // Reset the callstack + iReCallStack.Reset(); + + // Find the current thread callstack start address + TUint32 stackstart( 0 ); + TBool found( FindCurrentThreadStack( stackstart ) ); + LOGSTR3( "ATMH > stackstart: %x , found = %i", stackstart, found ); + + // Get codeblocks count + TInt blocksCount( iCodeblocks.Count() ); + TInt error( KErrNone ); + TUint arrayCounter = 0; + + for ( TUint32 i = __current_sp(); i < stackstart; i = i + KAddressLength )//lint !e1055 !e526 !e628 !e348 + { + TUint32 addr = (TUint32) *( (TUint32*) i ); + if ( ! IsAddressLoadedCode( addr ) ) + continue; + for ( TInt j = 0; j < blocksCount; j++ ) + { + if ( iCodeblocks[j].CheckAddress( addr ) ) + { + // To avoid recursive call to ReAlloc specifying granularity + // Add address to the callstack + iReCallStack[arrayCounter] = ( addr ); + arrayCounter++; + break; + } + } + if ( arrayCounter == KATMaxCallstackLength || + arrayCounter == iAllocMaxCallStack ) + { + LOGSTR2( "ATMH > Wanted CallStack items ready( %i )", arrayCounter ); + break; + } + } + + // No need to report free if the aPtr was NULL + if ( aPtr != NULL ) + { + // Reset the free callstack + iFreeCallStack.Reset(); + + // if trace logging mode(s) we also log call stack with free. + if ( ( iLogOption == EATUseDefault || iLogOption == EATLogToTrace || iLogOption == EATLogToTraceFast ) + && iFreeMaxCallStack > 0 ) + { + for ( TInt i = 0; i < arrayCounter; i++ ) + { + if ( i == iFreeCallStack.Count() ) + { + 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 mode. + ATFastLogMemoryAllocated( iProcessId, (TUint32) ptr, iReCallStack, aSize ); + } + else + { + // Using storage server. + error = iStorageServer.LogMemoryAllocated( (TUint32) ptr, + iReCallStack, + aSize ); + if ( KErrNone != error ) + { + LOGSTR2( "ATMH LogMemoryAllocated ReAlloc error %i", error ); + switch ( error ) + { + case KErrNoMemory: + LOGSTR1( "ATMH RAnalyzeToolAllocator::ReAlloc() - KErrNoMemory case" ); + if ( iStorageServerOpen ) + { + iStorageServerOpen = EFalse; + LOGSTR1( "ATMH RAnalyzeToolAllocator::ReAlloc() - close iStorageServer" ); + iStorageServer.Close(); + } + break; + } + } + } + } + } + + // Release the mutex + iMutex.Signal(); + + // Return pointer to the reallocated cell + return ptr; + } + +#endif // __WINS__ + +// ----------------------------------------------------------------------------- +// RAnalyzeToolAllocator::Compress() +// The function frees excess committed space from the top of the heap. +// The size of the heap is never reduced below the minimum size +// specified during creation of the heap. +// ----------------------------------------------------------------------------- +// +TInt RAnalyzeToolAllocator::Compress() + { + LOGSTR1( "ATMH RAnalyzeToolAllocator::Compress()" ); + + // Acquire the mutex + iMutex.Wait(); + + // Compress the memory using original allocator + TInt compress = iAllocator->Compress(); + + // Release the mutex + iMutex.Signal(); + + // Return the space reclaimed + return compress; + } + +// ----------------------------------------------------------------------------- +// RAnalyzeToolAllocator::Reset() +// Frees all allocated cells on this heap. +// ----------------------------------------------------------------------------- +// +void RAnalyzeToolAllocator::Reset() + { + LOGSTR1( "ATMH RAnalyzeToolAllocator::Reset()" ); + + // Acquire the mutex + iMutex.Wait(); + + // Reset the memory using original allocator + iAllocator->Reset(); + + // Release the mutex + iMutex.Signal(); + } + +// ----------------------------------------------------------------------------- +// RAnalyzeToolAllocator::AllocSize() +// Gets the number of cells allocated on this heap, and +// the total space allocated to them. +// ----------------------------------------------------------------------------- +// +TInt RAnalyzeToolAllocator::AllocSize( TInt& aTotalAllocSize ) const + { + LOGSTR1( "ATMH RAnalyzeToolAllocator::AllocSize()" ); + + // Acquire the mutex + iMutex.Wait(); + + // Acquire the memory information using original allocator + TInt size = iAllocator->AllocSize( aTotalAllocSize ); + + // Release the mutex + iMutex.Signal(); + + // Return the number of cells allocated on this heap. + return size; + } + +// ----------------------------------------------------------------------------- +// RAnalyzeToolAllocator::Available() +// Gets the total free space currently available on the heap and the +// space available in the largest free block. The space available +// represents the total space which can be allocated. Note that +// compressing the heap may reduce the total free space available +// and the space available in the largest free block. +// ----------------------------------------------------------------------------- +// +TInt RAnalyzeToolAllocator::Available( TInt& aBiggestBlock ) const + { + LOGSTR1( "ATMH RAnalyzeToolAllocator::Available()" ); + + // Acquire the mutex + iMutex.Wait(); + + // Acquire the memory information using original allocator + TInt available = iAllocator->Available( aBiggestBlock ); + + // Release the mutex + iMutex.Signal(); + + // Return the total free space currently available on the heap + return available; + } + +// ----------------------------------------------------------------------------- +// RAnalyzeToolAllocator::AllocLen() +// Gets the length of the available space in the specified +// allocated cell. +// ----------------------------------------------------------------------------- +// +TInt RAnalyzeToolAllocator::AllocLen( const TAny* aCell ) const + { + LOGSTR1( "ATMH RAnalyzeToolAllocator::AllocLen()" ); + + // Acquire the mutex + iMutex.Wait(); + + // Acquire the memory information using original allocator + TInt len = iAllocator->AllocLen( aCell ); + + // Release the mutex + iMutex.Signal(); + + // Return the length of the available space in the allocated cell. + return len; + } + +// ----------------------------------------------------------------------------- +// RAnalyzeToolAllocator::DebugFunction() +// Invocates specified debug funtionality. +// ----------------------------------------------------------------------------- +// +TInt RAnalyzeToolAllocator::DebugFunction( TInt aFunc, TAny* a1, TAny* a2 ) + { + LOGSTR2( "ATMH RAnalyzeToolAllocator::DebugFunction() %i", aFunc ); + + // Acquire the mutex + iMutex.Wait(); + + // Invocate debug funtion using original allocator + TInt debug = iAllocator->DebugFunction( aFunc, a1, a2 ); + + switch( aFunc ) + { + case EMarkEnd: + { + // Disables the __UHEAP_MARKEND macro + LOGSTR1( "ATMH __UHEAP_MARKEND macro called" ); + if ( debug > 0 ) + { + LOGSTR2( "ATMH __UHEAP_MARKEND detects leaks: %d", debug ); + // Because there is leaks the alloc panic will occur but + // lets return a zero to pretend that everything is OK + debug = 0; + } + } + break; + + default: + { + } + break; + } + + // Release the mutex + iMutex.Signal(); + + // Return information of the debug function success + return debug; + } + +// ----------------------------------------------------------------------------- +// RAnalyzeToolAllocator::Extension_() +// Extension function +// ----------------------------------------------------------------------------- +// +TInt RAnalyzeToolAllocator::Extension_( TUint aExtensionId, TAny*& a0, + TAny* a1 ) + { + LOGSTR1( "ATMH RAnalyzeToolAllocator::Extension_()" ); + + // Acquire the mutex + iMutex.Wait(); + + // Invocate extension funtion using original allocator + TInt ext = RAllocator::Extension_( aExtensionId, a0, a1 ); + + // Release the mutex + iMutex.Signal(); + + // Return information of the extension function success + return ext; + } + +// ----------------------------------------------------------------------------- +// RAnalyzeToolAllocator::ShareHeap() +// Share heap with other thread +// ----------------------------------------------------------------------------- +// +void RAnalyzeToolAllocator::ShareHeap() + { + LOGSTR1( "ATMH RAnalyzeToolAllocator::ShareHeap()" ); + + // Call the overwrited Open function + Open(); + } + +// ----------------------------------------------------------------------------- +// RAnalyzeToolAllocator::FindCurrentThreadStack() +// Find the current thread which is using the heap +// ----------------------------------------------------------------------------- +// +TBool RAnalyzeToolAllocator::FindCurrentThreadStack( TUint32& aStackStart ) + { + LOGSTR2( "ATMH RAnalyzeToolAllocator::FindCurrentThreadStack(), count( %i )", + iThreadArray.Count() ); + + // Flag for indicating that right thread has been found + TBool found( EFalse ); + // If threre is only one thread it must be the right thread + if ( iThreadArray.Count() == KThreadCount ) + { + if ( !iThreadArray[ 0 ].ThreadStackStart( aStackStart ) ) + { + // This MUST BE the right thread + //__ASSERT_ALWAYS( EFalse, AssertPanic( ECantFindRightThread ) ); + } + else if ( iThreadArray[ 0 ].ThreadStackStart( aStackStart ) ) + { + found = ETrue; + } + } + else + { + // Iterate through array to find right thread + TInt count( iThreadArray.Count() ); + + for ( TInt i = 0; i < count; i++ ) + { + // Check if this is the right thread + if ( iThreadArray[ i ].ThreadStackStart( aStackStart ) ) + { + // Right thread found. Mark the flag + found = ETrue; + break; + } + } + // If right thread was not found the panic must be raised + if ( !found ) + { + //__ASSERT_ALWAYS( EFalse, AssertPanic( ECantFindRightThread ) ); + } + } + return found; + } + +// End of File diff -r d27dfa8884ad -r da2cedce4920 analyzetool/dynamicmemoryhook/src/analyzetooleventhandler.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/dynamicmemoryhook/src/analyzetooleventhandler.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,230 @@ +/* +* 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 CLibraryEventHandler. +* +*/ + + +// INCLUDE FILES +#include "atlog.h" +#include "analyzetooleventhandler.h" +#include "analyzetooleventhandlernotifier.h" +#include "analyzetoolmemoryallocator.h" +#include "analyzetoolfastlog.h" + +// ----------------------------------------------------------------------------- +// CLibraryEventHandler::~CLibraryEventHandler() +// Destructor. +// ----------------------------------------------------------------------------- +// +CLibraryEventHandler::~CLibraryEventHandler() + { + LOGSTR1( "ATMH CLibraryEventHandler::~CLibraryEventHandler()" ); + Cancel(); + } + +// ----------------------------------------------------------------------------- +// CLibraryEventHandler::RunL() +// Process active object's task +// ----------------------------------------------------------------------------- +// +void CLibraryEventHandler::RunL() + { + LOGSTR1( "ATMH CLibraryEventHandler::RunL()" ); + + if ( KErrNone != iStatus.Int() ) + { + LOGSTR2( "ATMH RunL error: %i", iStatus.Int() ); + return; + } + // Acquire the mutex + iMutex.Wait(); + + // Check that this is observed process + if ( iLibraryInfo.iEventType == TLibraryEventInfo::ELibraryAdded ) + { + LOGSTR1( "ATMH CLibraryEventHandler::RunL() - TLibraryEventInfo::ELibraryAdded" ); + if ( iLibraryInfo.iProcessId == iProcessId ) + { + TInt error( KErrNone ); + + // Log library load event. + if ( iLogOption == EATLogToTraceFast ) + { + LOGSTR1( "ATMH CLibraryEventHandler::RunL() - ATFastLog.LogDllLoaded() " ); + ATFastLogDllLoaded( iProcessId, + iLibraryInfo.iLibraryName, + iLibraryInfo.iRunAddress, + iLibraryInfo.iRunAddress + iLibraryInfo.iSize ); + } + else + { + LOGSTR1( "ATMH CLibraryEventHandler::RunL() - iStorageServer.LogDllLoaded() " ); + error = iStorageServer.LogDllLoaded( + iLibraryInfo.iLibraryName, + iLibraryInfo.iRunAddress, + iLibraryInfo.iRunAddress + iLibraryInfo.iSize ); + LOGSTR2( "ATMH StorageServer error: %i", error ); + } + if ( KErrNone == error ) + { + iCodeblocks.Append( TCodeblock( iLibraryInfo.iRunAddress, + iLibraryInfo.iSize, + iLibraryInfo.iLibraryName ) ); + } + } + } + else if ( iLibraryInfo.iEventType == TLibraryEventInfo::ELibraryRemoved ) + { + LOGSTR1( "ATMH CLibraryEventHandler::RunL() - TLibraryEventInfo::ELibraryRemoved " ); + TInt count = iCodeblocks.Count(); + LOGSTR2( "ATMH count of code blocks: %i", count ); + for ( TInt i = 0; i < count; i++ ) + { + if ( iCodeblocks[ i ].Match( iLibraryInfo.iLibraryName ) ) + { + TBuf8 libraryName; + libraryName.Copy( iLibraryInfo.iLibraryName ); + + // Log library unloaded event + if ( iLogOption == EATLogToTraceFast ) + { + LOGSTR1( "ATMH CLibraryEventHandler::RunL() - ATFastLogDllUnloaded() " ); + ATFastLogDllUnloaded( iProcessId, + libraryName, + iLibraryInfo.iRunAddress, + iLibraryInfo.iRunAddress + iLibraryInfo.iSize ); + } + else + { + LOGSTR1( "ATMH CLibraryEventHandler::RunL() - iStorageServer.LogDllUnloaded() " ); + #ifdef LOGGING_ENABLED + TInt error = iStorageServer.LogDllUnloaded( + libraryName/*iLibraryInfo.iLibraryName*/, + iLibraryInfo.iRunAddress, + iLibraryInfo.iRunAddress + iLibraryInfo.iSize ); + + LOGSTR2( "ATMH StorageServer error: %i", error ); + #else + iStorageServer.LogDllUnloaded( + libraryName/*iLibraryInfo.iLibraryName*/, + iLibraryInfo.iRunAddress, + iLibraryInfo.iRunAddress + iLibraryInfo.iSize ); + #endif + } + iCodeblocks.Remove( i ); + break; + } + } + } + else if ( iLibraryInfo.iEventType == TLibraryEventInfo::EKillThread ) + { + LOGSTR1( "ATMH CLibraryEventHandler::RunL() - TLibraryEventInfo::EKillThread" ); + + iNotifier.RemoveKilledThread( iLibraryInfo.iThreadId ); + } + + Start(); + + // Release the mutex + iMutex.Signal(); + } + +// ----------------------------------------------------------------------------- +// CLibraryEventHandler::DoCancel() +// Cancels active object's task +// ----------------------------------------------------------------------------- +// +void CLibraryEventHandler::DoCancel() + { + LOGSTR1( "ATMH CLibraryEventHandler::DoCancel()" ); + // Cancel the subscription of the library events + if ( IsActive() ) + { + iStarted = EFalse; + + iAnalyzeTool.CancelLibraryEvent(); + } + } + +// ----------------------------------------------------------------------------- +// CLibraryEventHandler::Start() +// Creates CActiveScheduler and variables for the child thread +// ----------------------------------------------------------------------------- +// +void CLibraryEventHandler::Start() + { + LOGSTR1( "ATMH CLibraryEventHandler::Start()" ); + + // Acquire the mutex + iMutex.Wait(); + + if ( !IsAdded() ) + { + CActiveScheduler::Add( this ); + } + + // Cancel current subscribetion + if ( IsActive() ) + { + iStarted = EFalse; + Cancel(); + } + + iStatus = KErrNone; + iAnalyzeTool.LibraryEvent( iStatus, iLibraryInfo ); + SetActive(); + + iStarted = ETrue; + // Release the mutex + iMutex.Signal(); + } + +// ----------------------------------------------------------------------------- +// CLibraryEventHandler::CLibraryEventHandler() +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CLibraryEventHandler::CLibraryEventHandler( RAnalyzeTool& aAnalyzeTool, + RArray& aCodeblocks, RATStorageServer& aStorageServer, + TUint aProcessId, RMutex& aMutex, + MAnalyzeToolEventhandlerNotifier& aNotifier, + TUint32 aLogOption ) + : CActive( EPriorityNormal ), + iAnalyzeTool( aAnalyzeTool ), + iCodeblocks( aCodeblocks ), + iStorageServer( aStorageServer ), + iProcessId( aProcessId ), + iMutex( aMutex ), + iStarted( EFalse ), + iNotifier( aNotifier ), + iLogOption( aLogOption ) + { + LOGSTR1( "ATMH CLibraryEventHandler::CLibraryEventHandler()" ); + } + +// ----------------------------------------------------------------------------- +// CLibraryEventHandler::IsStarted() +// Returns eventhandler's state. +// ----------------------------------------------------------------------------- +// +TBool CLibraryEventHandler::IsStarted() + { + LOGSTR2( "ATMH CLibraryEventHandler::IsStarted(%i)", iStarted ); + + return iStarted; + } + +// End of File diff -r d27dfa8884ad -r da2cedce4920 analyzetool/dynamicmemoryhook/src/analyzetoolfastlog.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/dynamicmemoryhook/src/analyzetoolfastlog.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,298 @@ +/* +* 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: +* +*/ + + +#include // RDebug +#include +#include "analyzetoolfastlog.h" +#include "atlog.h" + +// Local time function. +TInt64 CurrentTime() + { + LOGSTR1( "ATFL CurrentTime()" ); + TTime time; + time.UniversalTime(); + return time.Int64() - KMicroSecondsAt1970; + } + +TInt ATFastLogProcessStarted( const TDesC8& aProcessName, + TUint aProcessId, + TUint32 aIsDebug ) + { + LOGSTR1( "ATFL ATFastLogProcessStarted()" ); + // Convert process name to 16-bit descriptor. + TBuf processName; + processName.Copy( aProcessName ); + // Buffer to trace. + TBuf buffer; + // Format process name and id. + buffer.Format( KProcessStart16, &processName, aProcessId ); + // Timestamp. + buffer.AppendNum( CurrentTime(), EHex ) ; + // Append udeb/urel information to the process start. + buffer.Append( KSpaceTrace ); + buffer.AppendNum( aIsDebug, EHex ); + // Append version number. + buffer.Append( KSpaceTrace ); + buffer.AppendNum( KATTraceVersion, EHex ); + // Log to trace. + RDebug::Print( KTraceMessage, aProcessId ,&buffer ); + return KErrNone; + } + +TInt ATFastLogProcessEnded( TUint aProcessId, + TUint aHandleLeakCount ) + { + LOGSTR1( "ATFL ATFastLogProcessEnded()" ); + // Handle leaks. + if ( aHandleLeakCount > 0 ) + { + // Buffer to trace. + TBuf buffer2; + buffer2.Format( KHandleLeak16, &KUnknownModule16, aHandleLeakCount ); + // Trace it. + RDebug::Print( KTraceMessage, aProcessId, &buffer2 ); + } + // Process end trace. + TBuf buffer; + buffer.Format( KProcessEnd16, aProcessId ); + buffer.AppendNum( CurrentTime(), EHex); + buffer.Append( KNewLineTrace ); + RDebug::Print( KTraceMessage, aProcessId, &buffer ); + return KErrNone; + } + +TInt ATFastLogDllLoaded( TUint aProcessId, + const TDesC8& aDllName, + TUint32 aStartAddress, + TUint32 aEndAddress ) + { + LOGSTR1( "ATFL ATFastLogDllLoaded()" ); + // Timestamp. + TInt64 time = CurrentTime(); + // Convert dll name to 16-bit descriptor. + TBuf dll; + dll.Copy( aDllName ); + // Buffer to trace. + TBuf buffer; + buffer.Format( KDllLoad16, &dll, time, aStartAddress, aEndAddress ); + RDebug::Print( KTraceMessage, aProcessId, &buffer ); + return KErrNone; + } + +TInt ATFastLogDllUnloaded( TUint aProcessId, const TDesC8& aDllName, TUint32 aStartAddress, + TUint32 aEndAddress ) + { + LOGSTR1( "ATFL ATFastLogDllUnloaded()" ); + // Timestamp. + TInt64 time = CurrentTime(); + // Convert dll name to 16-bit descriptor. + TBuf dll; + dll.Copy( aDllName ); + // Buffer to trace. + TBuf buffer; + buffer.Format( KDllUnload16, &dll, time, aStartAddress, aEndAddress ); + RDebug::Print( KTraceMessage, aProcessId, &buffer ); + return KErrNone; + } + +TInt ATFastLogMemoryAllocated( TUint aProcessId, TUint32 aMemAddress, + TFixedArray& aCallstack, + TInt aSize ) + { + LOGSTR1( "ATFL ATFastLogMemoryAllocated()" ); + // ALLOCH + // ... + + // Timestamp. + TInt64 time = CurrentTime(); + + // Trace buffer and pointer to it. + TBufC buffer; + TPtr ptr( buffer.Des() ); + // Append the tag implying a memory allocation line in the data file + ptr.Append( KMemoryAllocHeader ); + + // Append the start address of this allocation in the 32-bit (max 8 characters) + // hexadecimal text format. + ptr.AppendNum( aMemAddress, EHex ); + + // Append the current time in the 64-bit (max 16 characters) hexadecimal text + // format + ptr.Append( KSpaceTrace ); + ptr.AppendNum( time, EHex ); + + // Append the size of the allocation in the 32-bit (max 8 characters) hexadecimal + // text format. + ptr.Append( KSpaceTrace ); + ptr.AppendNum( aSize, EHex ); + + // Search call stack for address count. + TInt addrCount(0); + for ( TInt j = 0; j < aCallstack.Count() ; j++ ) + { + if ( aCallstack.At(j) == 0 ) + break; + addrCount++; + } + // Current position in call stack. + TInt addrPos( 0 ); + + // Append address count. + ptr.Append( KSpaceTrace ); + ptr.AppendNum( addrCount, EHex ); + + // Calculate last item length + TInt lastItemLength( KTraceMessage().Length() + KHexa32Length + + KSpaceLength + KNewlineLength ); + + TUint packetNumber( 1 ); + + // Go through all call stack's memory addresses associated with + // this memory allocation + for ( TInt j = 0; j < addrCount; j++ ) + { + // ALLOCF + // ... + if ( ptr.Length() <= 0 ) + { + // Create alloc fragment message header + ptr.Append( KMemoryAllocFragment ); + ptr.AppendNum( aMemAddress, EHex ); + ptr.Append( KSpaceTrace ); + ptr.AppendNum( time, EHex ); + ptr.Append( KSpaceTrace ); + ptr.AppendNum( packetNumber, EHex ); + // Increase packet number + packetNumber++; + } + + // Append call stack address. + ptr.AppendFormat( KHexaNumberTrace, aCallstack.At( addrPos ) ); + + // Move the call stack position. + addrPos++; + + // Check if buffer max length exceed + if ( lastItemLength + ptr.Length() >= KMemAllocBufLength ) + { + ptr.Append( KNewLineTrace ); + // Log through debug channel + RDebug::Print( KTraceMessage, aProcessId, &buffer ); + // Empty trace buffer + ptr.Delete( 0, ptr.MaxLength() ); + } + } + // Send last message if exists. + if ( ptr.Length() > 0 ) + { + ptr.Append( KNewLineTrace ); + RDebug::Print( KTraceMessage, aProcessId, &buffer); + } + return KErrNone; + } + + +TInt ATFastLogMemoryFreed( TUint aProcessId, TUint32 aMemAddress, + TFixedArray& aFreeCallstack ) + { + LOGSTR1( "ATFL ATFastLogMemoryFreed()" ); + // FREEH + // ... + + // Timestamp. + TInt64 time = CurrentTime(); + + // Trace buffer and pointer to it. + TBufC buffer; + TPtr ptr( buffer.Des() ); + + // Append the tag implying a memory allocation line in the data file + ptr.Append( KMemoryFreedHeader ); + + // Append the start address of this allocation in the 32-bit (max 8 characters) + // hexadecimal text format. + ptr.AppendNum( aMemAddress, EHex ); + + // Append timestamp; + ptr.Append( KSpaceTrace ); + ptr.AppendNum( time, EHex); + + // Search call stack for address count. + TInt addrCount(0); + for ( TInt j = 0; j < aFreeCallstack.Count() ; j++ ) + { + if ( aFreeCallstack.At(j) == 0 ) + break; + addrCount++; + } + // Current position in call stack. + TInt addrPos( 0 ); + + // Append address count. + ptr.Append( KSpaceTrace ); + ptr.AppendNum( addrCount, EHex ); + + // Calculate last item length + TInt lastItemLength( KTraceMessage().Length() + KHexa32Length + + KSpaceLength + KNewlineLength ); + + TUint packetNumber( 1 ); + + // Go through all call stack's memory addresses associated with + // this memory allocation + for ( TInt j = 0; j < addrCount; j++ ) + { + // ALLOCF + // ... + if ( ptr.Length() <= 0 ) + { + // Create alloc fragment message header + ptr.Append( KMemoryFreedFragment ); + ptr.AppendNum( aMemAddress, EHex ); + ptr.Append( KSpaceTrace ); + ptr.AppendNum( packetNumber, EHex ); + // Increase packet number + packetNumber++; + } + + // Append call stack address. + ptr.AppendFormat( KHexaNumberTrace, aFreeCallstack.At( addrPos ) ); + + // Move the call stack position. + addrPos++; + + // Check if buffer max length exceed + if ( lastItemLength + ptr.Length() >= KMemFreedBufLength ) + { + ptr.Append( KNewLineTrace ); + // Log through debug channel + RDebug::Print( KTraceMessage, aProcessId, &buffer ); + // Empty trace buffer + ptr.Delete( 0, ptr.MaxLength() ); + } + } + // Send last message if exists. + if ( ptr.Length() > 0 ) + { + ptr.Append( KNewLineTrace ); + RDebug::Print( KTraceMessage, aProcessId, &buffer); + } + return KErrNone; + } + diff -r d27dfa8884ad -r da2cedce4920 analyzetool/dynamicmemoryhook/src/analyzetoolmainallocator.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/dynamicmemoryhook/src/analyzetoolmainallocator.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,1509 @@ +/* +* 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 RAnalyzeToolMainAllocator. +* +*/ + + +#include "analyzetoolmainallocator.h" +#include "atlog.h" +#include "analyzetooleventhandler.h" +#include "analyzetoolmemoryallocator.h" +#include "analyzetoolpanics.pan" +#include "analyzetoolfastlog.h" +#include + + +// 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; + +// ----------------------------------------------------------------------------- +// RAnalyzeToolMainAllocator::RAnalyzeToolMainAllocator() +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +RAnalyzeToolMainAllocator::RAnalyzeToolMainAllocator( TBool aNotFirst, + const TFileName aFileName, TUint32 aLogOption, TUint32 aIsDebug, + TUint32 aAllocCallStackSize, TUint32 aFreeCallStackSize ) : + RAnalyzeToolMemoryAllocator( aNotFirst ), + iAnalyzeToolOpen( EFalse ), + iDeviceDriverLoaded( EFalse ), + iCodeblocks( KATMaxCallstackLength ), + iThreadArray( KATMaxCallstackLength ), + iLogOption( aLogOption ), + iProcessId( RProcess().Id().operator TUint() ), + iAllocMaxCallStack( aAllocCallStackSize ), + iFreeMaxCallStack( aFreeCallStackSize ) + { + 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 ) ); + + LOGSTR2( "ATMH Creating mutex error %i", error ); + + // Load the kernel side device driver + error = User::LoadLogicalDevice( KAnalyzeToolLddName ); + + if ( error != KErrNone && error != KErrAlreadyExists ) + { + __ASSERT_ALWAYS( EFalse, AssertPanic( ECantLoadDeviceDriver ) ); + } + else + { + iDeviceDriverLoaded = ETrue; + } + + LOGSTR2( "ATMH Loading device driver error %i", error ); + + // Open handle to the kernel sidedevice driver + error = iAnalyzeTool.Open(); + + __ASSERT_ALWAYS( KErrNone == error, AssertPanic( ECantConnectDeviceDriver ) ); + + if ( KErrNone == error ) + { + iAnalyzeToolOpen = ETrue; + } + + LOGSTR2( "ATMH Opening RAnalyzeTool handle %i error", error ); + + // Set memory model by asking kernel side device driver + if ( iAnalyzeToolOpen ) + { + TATMemoryModelBuf model; + if ( KErrNone == iAnalyzeTool.GetMemoryModel( model ) ) + { + iMemoryModel = model().iMemoryModel; + LOGSTR2( "ATMH AnalyzeTool MemoryModel: %i", iMemoryModel ); + } + else + LOGSTR2( "ATMH AnalyzeTool GetMemoryModel error: %i", error ); + } + + // Retrieve the initial process information + LogProcessInformation( aFileName, aLogOption, aIsDebug ); + + // Create handler for receiving kernel events + iEventHandler = new CLibraryEventHandler( iAnalyzeTool, + iCodeblocks, + iStorageServer, + iProcessId, + iMutex, + *this, + aLogOption); + + __ASSERT_ALWAYS( iEventHandler != NULL, AssertPanic( ENoMemory ) ); + } + +// ----------------------------------------------------------------------------- +// RAnalyzeToolMainAllocator::~RAnalyzeToolMainAllocator() +// Destructor. +// ----------------------------------------------------------------------------- +// +RAnalyzeToolMainAllocator::~RAnalyzeToolMainAllocator() + { + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::~RAnalyzeToolMainAllocator()" ); + + TUint handleLeakCount( 0 ); + if ( iAnalyzeToolOpen && iThreadArray.Count() > 0 ) + { + TProcessHandleInfoBuf params; + params().iProcessId = iProcessId; + TInt error( iAnalyzeTool.GetProcessHandleInfo( params ) ); + handleLeakCount = params().iThreadHandleCount; + } + + // Close handle for process memory blocks + iCodeblocks.Close(); + + // Delete the eventhandler + delete iEventHandler; + + // The count of device driver users + TClientCountBuf count; + + // Check the flag + if ( iAnalyzeToolOpen ) + { + TInt error = iAnalyzeTool.ClientCount( count ); + LOGSTR2( "ATMH closing analyze tool handle error: %i", error ); + iAnalyzeTool.Close(); + } + + // Check the flag + if ( iDeviceDriverLoaded ) + { + LOGSTR2( "ATMH device driver client count: %i", count().iClientCount ); + + // Check if there is another user for device driver + if ( count().iClientCount <= 1 ) + { + // There was no other users -> unload the device driver + TInt error = User::FreeLogicalDevice( KAnalyzeToolLddName ); + LOGSTR2( "ATMH Unloading ldd error: %i", error ); + } + } + + // Close the thread array + iThreadArray.Close(); + + if ( iStorageServerOpen || iLogOption == EATLogToTraceFast ) + { + if ( iLogOption == EATLogToTraceFast ) + { + LOGSTR1( "ATMH ATFastLogProcessEnded()" ); + ATFastLogProcessEnded( iProcessId, 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(); + } + +// ----------------------------------------------------------------------------- +// RAnalyzeToolMainAllocator::ShareHeap() +// Share heap with other thread +// ----------------------------------------------------------------------------- +// +void RAnalyzeToolMainAllocator::ShareHeap() + { + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::ShareHeap()" ); + + // Call the overwrited Open function + Open(); + } + +// ----------------------------------------------------------------------------- +// RAnalyzeToolMainAllocator::Uninstall() +// Uninstalls the current allocator +// ----------------------------------------------------------------------------- +// +void RAnalyzeToolMainAllocator::Uninstall() + { + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::Uninstall()" ); + + // Acquire the mutex + iMutex.Wait(); + + TMainThreadParamsBuf params; + params().iProcessId = iProcessId; + iAnalyzeTool.MainThreadAlloctor( params ); + + // Release the mutex + iMutex.Signal(); + + // Check if this is shared allocator between threads + if ( iThreadArray.Count() > KThreadCount && !params().iAlone ) + { + // Close the shared allocator + Close(); + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::Uninstall() - Close called" ); + return; + } + +#if ( SYMBIAN_VERSION_SUPPORT >= SYMBIAN_3 ) + #ifndef __WINS__ + // Remove dummy Tls handle + UserSvr::DllFreeTls( KDummyHandle ); + #endif +#endif + + // Since this is the last thread using this allocator it can be deleted + delete this; + } + +#ifdef __WINS__ +// ----------------------------------------------------------------------------- +// RAnalyzeToolMainAllocator::Alloc() WINS version +// Allocates a cell of specified size from the heap. +// ----------------------------------------------------------------------------- +// +UEXPORT_C TAny* RAnalyzeToolMainAllocator::Alloc( TInt aSize ) + { + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::Alloc()" ); + + // Acquire the mutex + iMutex.Wait(); + + // 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 ); + + // Check if eventhandler is started already + if ( !iEventHandler->IsStarted() ) + { + // Install the eventhandler if needed + InstallEventHandler(); + } + + // Reset the callstack + iCallStack.Reset(); + + // If we don't want any call stack to be saved skip the next part + if( iAllocMaxCallStack > 0 ) + { + // Find the current thread callstack start address + TUint32 stackstart( 0 ); + TBool found( FindCurrentThreadStack( stackstart ) ); + LOGSTR3( "ATMH > stackstart: %x , found = %i", stackstart, found ); + + // Returns the value of the stack pointer at the + // current point in your program. + TUint32 _sp; + __asm + { + mov [_sp], esp + } + + // Get process loaded code segments count + TInt blocksCount( iCodeblocks.Count() ); + TUint arrayCounter = 0; + + // Iterate through callstack to find wanted callstack addresses + // - Start: current stack address + // - Stop: stack start address(Run-address of user stack) + // - Add: address length(The word size in the current system is 32 bits, which is 4 bytes) + for ( TUint32 i = _sp; i < stackstart; i = i + KAddressLength )//lint !e1055 !e526 !e628 !e348 + { + TUint32 addr = (TUint32) *( (TUint32*) i ); + + // Checks is the given address in loaded code memory area. + if ( !IsAddressLoadedCode( addr ) ) + continue; + + // Iterate through array of code blocks to check if address is in code segment area + for ( TInt j = 0; j < blocksCount; j++ ) + { + // Checks if the given address is in this memory block area + if ( iCodeblocks[j].CheckAddress( addr ) ) + { + // To avoid recursive call to ReAlloc specifying granularity + // Add address to the callstack + iCallStack[arrayCounter] = ( addr ); + arrayCounter++; + break; + } + } + + // Checks if the wanted callstack items are gathered + if ( arrayCounter == KATMaxCallstackLength || + arrayCounter == iAllocMaxCallStack ) + { + LOGSTR2( "ATMH > Wanted CallStack items ready( %i )", arrayCounter ); + break; + } + } + } + + // Log the memory allocation information + if ( iLogOption == EATLogToTraceFast ) + { + // Using fast mode. + ATFastLogMemoryAllocated( iProcessId, (TUint32) p , iCallStack, aSize ); + } + else + { + // Using storage server. + error = iStorageServer.LogMemoryAllocated( (TUint32) p, + iCallStack, + aSize ); + if ( KErrNone != error ) + { + switch ( error ) + { + case KErrNoMemory: + { + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::Alloc() - KErrNoMemory case" ); + // Check if eventhandler is active + if ( iEventHandler->IsActive() ) + { + // Cancel iEventHandler because not needed anymore + iEventHandler->Cancel(); + } + if ( iStorageServerOpen ) + { + // Close storage server + iStorageServerOpen = EFalse; + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::Alloc() - close iStorageServer" ); + iStorageServer.Close(); + } + break; + } + default: + { + LOGSTR2( "ATMH LogMemoryAllocated error %i", error ); + break; + } + } + } + } + } + // Release the mutex + iMutex.Signal(); + + return p; + } +#else + +// ----------------------------------------------------------------------------- +// RAnalyzeToolMainAllocator::Alloc() ARMV5 version +// Allocates a cell of specified size from the heap. +// ----------------------------------------------------------------------------- +// +TAny* RAnalyzeToolMainAllocator::Alloc( TInt aSize ) + { + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::Alloc()" ); + + // acquire the mutex + iMutex.Wait(); + + // 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 ); + + if ( iStorageServerOpen || iLogOption == EATLogToTraceFast ) + { + // Check if eventhandler is active already + // IsActive might return false value if a tested software has created many + // threads which install own CActiveScheduler. + if ( !iEventHandler->IsStarted() ) + { + // Install the eventhandler if needed + InstallEventHandler(); + } + + // Reset the callstack + iCallStack.Reset(); + + // If we don't want any call stack to be saved skip the next part + if( iAllocMaxCallStack > 0 ) + { + // Find the current thread callstack start address + TUint32 stackstart( 0 ); + TBool found( FindCurrentThreadStack( stackstart ) ); + LOGSTR3( "ATMH > stackstart: %x , found = %i", stackstart, found ); + + // Get process loaded code segments count + TInt blocksCount( iCodeblocks.Count() ); + TUint arrayCounter = 0; + + // Iterate through callstack to find wanted callstack addresses + // - Start: current stack address(__current_sp(): Returns the value of the + // stack pointer at the current point in your program.) + // - Stop: stack start address(Run-address of user stack) + // - Add: address length(The word size in the current system is 32 bits, which is 4 bytes) + for ( TUint32 i = __current_sp(); i < stackstart; i = i + KAddressLength )//lint !e1055 !e526 !e628 !e348 + { + TUint32 addr = (TUint32) *( (TUint32*) i ); + + // Checks is the given address in loaded code memory area. + if ( !IsAddressLoadedCode( addr ) ) + continue; + + // Iterate through array of code blocks to check if address is in code segment area + for ( TInt j = 0; j < blocksCount; j++ ) + { + // Checks if the given address is in this memory block area + if ( iCodeblocks[j].CheckAddress( addr ) ) + { + // To avoid recursive call to ReAlloc specifying granularity + // Add address to the callstack + iCallStack[arrayCounter] = ( addr ); + arrayCounter++; + break; + } + } + + // Checks if the wanted callstack items are gathered + if ( arrayCounter == KATMaxCallstackLength || + arrayCounter == iAllocMaxCallStack ) + { + LOGSTR2( "ATMH > Wanted CallStack items ready( %i )", arrayCounter ); + break; + } + } + } + // Log the memory allocation information + if ( iLogOption == EATLogToTraceFast ) + { + // Using fast mode. + ATFastLogMemoryAllocated( iProcessId, (TUint32) p, iCallStack, aSize ); + } + else + { + // Using storage server. + error = iStorageServer.LogMemoryAllocated( (TUint32) p, + iCallStack, + aSize ); + if ( KErrNone != error ) + { + switch ( error ) + { + case KErrNoMemory: + { + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::Alloc() - KErrNoMemory case" ); + // Check if eventhandler is active + if ( iEventHandler->IsActive() ) + { + // Cancel ieventhandler because not needed anymore + iEventHandler->Cancel(); + } + if ( iStorageServerOpen ) + { + // Close storage server + iStorageServerOpen = EFalse; + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::Alloc() - close iStorageServer" ); + iStorageServer.Close(); + } + break; + } + default: + { + LOGSTR2( "ATMH LogMemoryAllocated error %i", error ); + break; + } + } + } + } + } + + // Release the mutex + iMutex.Signal(); + + // Return the allocatated memory + return p; + } +#endif // __WINS__ + +// ----------------------------------------------------------------------------- +// RAnalyzeToolMainAllocator::Free() +// Frees the allocated memory +// ----------------------------------------------------------------------------- +// +void RAnalyzeToolMainAllocator::Free( TAny* aPtr ) + { + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::Free()" ); + + // Acquire the mutex + iMutex.Wait(); + + if ( iStorageServerOpen || iLogOption == EATLogToTraceFast ) + { + // Reset the callstack + iFreeCallStack.Reset(); + + // Check if trace logging mode + // Also if we don't want any call stack to be stored skip the next part + if ( (iLogOption == EATUseDefault || iLogOption == EATLogToTrace || iLogOption == EATLogToTraceFast ) + && iFreeMaxCallStack > 0 ) + { + // Find the current thread callstack start address + TUint32 stackstart( 0 ); + TBool found( FindCurrentThreadStack( stackstart ) ); + LOGSTR3( "ATMH > stackstart: %x , found = %i", stackstart, found ); + TUint32 _sp; + + // Returns the value of the stack pointer at the + // current point in your program. + #ifdef __WINS__ + __asm + { + mov [_sp], esp + } + #else + _sp = __current_sp(); + #endif + + // Get process loaded code segments count + TInt blocksCount( iCodeblocks.Count() ); + TUint arrayCounter = 0; + + // Iterate through callstack to find wanted callstack addresses + // - Start: current stack address + // - Stop: stack start address(Run-address of user stack) + // - Add: address length(The word size in the current system is 32 bits, which is 4 bytes) + for ( TUint32 i = _sp; i < stackstart; i = i + KAddressLength )//lint !e1055 !e526 !e628 !e348 + { + TUint32 addr = (TUint32) *( (TUint32*) i ); + // Checks is the given address in loaded code memory area. + if ( ! IsAddressLoadedCode( addr ) ) + continue; + + // Iterate through array of code blocks to check if address is in code segment area + for ( TInt j = 0; j < blocksCount; j++ ) + { + // Checks if the given address is in this memory block area + if ( iCodeblocks[j].CheckAddress( addr ) ) + { + // To avoid recursive call to ReAlloc specifying granularity + // Add address to the callstack + iFreeCallStack[arrayCounter] = addr; + arrayCounter++; + break; + } + } + // Checks if the wanted callstack items are gathered + if ( arrayCounter == KATMaxFreeCallstackLength || + arrayCounter == iFreeMaxCallStack ) + { + break; + } + } + LOGSTR2( "ATMH > iFreeCallStack count ( %i )", arrayCounter ); + } + // Log the memory free information. + if ( iLogOption == EATLogToTraceFast ) + { + // Using fast mode. + ATFastLogMemoryFreed( iProcessId, (TUint32) aPtr, iFreeCallStack ); + } + else + { + // Using storage server. + TInt err( iStorageServer.LogMemoryFreed( (TUint32) aPtr, iFreeCallStack ) ); + if ( err != KErrNone ) + { + LOGSTR2( "ATMH > LogMemoryFreed err( %i )", err ); + } + } + } + + // Free the memory using original allocator + iAllocator->Free( aPtr ); + + LOGSTR2( "ATMH RAnalyzeToolMainAllocator::Free() - aPtr: %x", (TUint32)aPtr ); + + // Release the mutex + iMutex.Signal(); + } + +// ----------------------------------------------------------------------------- +// RAnalyzeToolMainAllocator::Open() +// Opens this heap for shared access. Opening the heap increases +// the heap's access count by one. +// ----------------------------------------------------------------------------- +// +TInt RAnalyzeToolMainAllocator::Open() + { + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::Open() " ); + + // Acquire the mutex + iMutex.Wait(); + + // Share the memory using original allocator + TInt error = iAllocator->Open(); + + // If everything is OK add thread to the array which use this allocator + if ( KErrNone == error ) + { + TThreadParamsBuf params; + params().iThreadId = RThread().Id().operator TUint(); + error = iAnalyzeTool.ThreadStack( params ); + + __ASSERT_ALWAYS( KErrNone == error, AssertPanic( ECantAppendToTheArray ) ); + + if ( KErrNone == error ) + { + 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 ) ); + } + } + + // Release the mutex + iMutex.Signal(); + + // Return the error code + return error; + } + +// ----------------------------------------------------------------------------- +// RAnalyzeToolMainAllocator::Close() +// Closes this shared heap. Closing the heap decreases the heap's +// access count by one. +// ----------------------------------------------------------------------------- +// +void RAnalyzeToolMainAllocator::Close() + { + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::Close()" ); + + // Acquire the mutex + iMutex.Wait(); + + // Close the memory using original allocator + iAllocator->Close(); + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::Close() - allocator closed" ); + TInt count = iThreadArray.Count(); + + // Iterate through array of threads to remove current thread + for ( TInt i = 0; i < count; i++ ) + { + // Check if this is current thread + if ( iThreadArray[ i ].Match() ) + { + // Remove the thread + iThreadArray.Remove( i ); + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::Close() - thread removed" ); + break; + } + } + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::Close() - about to mutex signal" ); + // Release the mutex + iMutex.Signal(); + } + +#ifdef __WINS__ + +// ----------------------------------------------------------------------------- +// RAnalyzeToolMainAllocator::ReAlloc() +// Increases or decreases the size of an existing cell. +// ----------------------------------------------------------------------------- +// +TAny* RAnalyzeToolMainAllocator::ReAlloc( TAny* aPtr, TInt aSize, TInt aMode ) + { + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::ReAlloc()" ); + + // Acquire the mutex + iMutex.Wait(); + + // Realloc the memory using original allocator + TAny* ptr = iAllocator->ReAlloc( aPtr, aSize, aMode ); + + // 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. + if ( iStorageServerOpen || iLogOption == EATLogToTraceFast ) + { + TInt error( KErrNone ); + TUint arrayCounter = 0; + + // Reset the callstack + iReCallStack.Reset(); + + // If we don't want any call stack to be saved skip the next part + if( iAllocMaxCallStack > 0 ) + { + // Find the current thread callstack start address + TUint32 stackstart( 0 ); + TBool found( FindCurrentThreadStack( stackstart ) ); + LOGSTR3( "ATMH > stackstart: %x , find = %i", stackstart, found ); + + // Returns the value of the stack pointer at the + // current point in your program. + TUint32 _sp( 0 ); + __asm + { + mov [_sp], esp + } + + // Get process loaded code segments count + TInt blocksCount( iCodeblocks.Count() ); + + // Iterate through callstack to find wanted callstack addresses + // - Start: current stack address + // - Stop: stack start address(Run-address of user stack) + // - Add: address length(The word size in the current system is 32 bits, which is 4 bytes) + for ( TUint32 i = _sp; i < stackstart; i = i + KAddressLength )//lint !e1055 !e526 !e628 !e348 + { + TUint32 addr = (TUint32) *( (TUint32*) i ); + // Checks is the given address in loaded code memory area. + if ( ! IsAddressLoadedCode( addr ) ) + continue; + + // Iterate through array of code blocks to check if address is in code segment area + for ( TInt j = 0; j < blocksCount; j++ ) + { + // Checks if the given address is in this memory block area + if ( iCodeblocks[j].CheckAddress( addr ) ) + { + // To avoid recursive call to ReAlloc specifying granularity + // Add address to the callstack + iReCallStack[arrayCounter] = addr; + arrayCounter++; + break; + } + } + // Checks if the wanted callstack items are gathered + if ( arrayCounter == KATMaxCallstackLength || + arrayCounter == iAllocMaxCallStack ) + { + LOGSTR2( "ATMH > Wanted CallStack items ready( %i )", arrayCounter ); + break; + } + } + } + + // No need to report free if the aPtr was NULL + if ( aPtr != NULL ) + { + // Reset the free callstack + iFreeCallStack.Reset(); + + // Check that logging mode is trace/trace fast so we use free call stack + // and call stack size bigger than zero + if ( ( iLogOption == EATUseDefault || iLogOption == EATLogToTrace || iLogOption == EATLogToTraceFast ) && iFreeMaxCallStack > 0 ) + { + for ( TInt i = 0; i < arrayCounter; i++ ) + { + if ( i == KATMaxFreeCallstackLength || i == iFreeMaxCallStack ) + { + break; + } + iFreeCallStack[i] = iReCallStack[i]; + } + } + // Try to remove old address from the storage server's + // leak array. If found. it's removed from the array because system frees + // old address directly in the RHeap in ReAlloc case. + if ( iLogOption == EATLogToTraceFast ) + { + ATFastLogMemoryFreed( iProcessId, (TUint32) aPtr, iFreeCallStack ); + } + else + { + iStorageServer.LogMemoryFreed( (TUint32) aPtr, iFreeCallStack ); + } + } + // Log the memory allocation information + if ( iLogOption == EATLogToTraceFast ) + { + // Using fast logging mode. + ATFastLogMemoryAllocated( iProcessId, (TUint32) ptr, iReCallStack, aSize ); + } + else + { + // Using storage server. + error = iStorageServer.LogMemoryAllocated( (TUint32) ptr, + iReCallStack, + aSize ); + if ( KErrNone != error ) + { + switch ( error ) + { + case KErrNoMemory: + { + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::ReAlloc() - KErrNoMemory case" ); + // Check if eventhandler is active + if ( iEventHandler->IsActive() ) + { + // Cancel iEventHandler because not needed anymore + iEventHandler->Cancel(); + } + if ( iStorageServerOpen ) + { + // Close storage server + iStorageServerOpen = EFalse; + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::ReAlloc() - close iStorageServer" ); + iStorageServer.Close(); + } + break; + } + default: + { + LOGSTR2( "ATMH LogMemoryAllocated error %i", error ); + break; + } + } + } + } + } + } + + // Release the mutex + iMutex.Signal(); + + // Return pointer to the reallocated cell + return ptr; + } + +#else + +// ----------------------------------------------------------------------------- +// RAnalyzeToolMainAllocator::ReAlloc() +// Increases or decreases the size of an existing cell. +// ----------------------------------------------------------------------------- +// +TAny* RAnalyzeToolMainAllocator::ReAlloc( TAny* aPtr, TInt aSize, TInt aMode ) + { + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::ReAlloc()" ); + + // Acquire the mutex + iMutex.Wait(); + + // 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. + if ( iStorageServerOpen || iLogOption == EATLogToTraceFast ) + { + // Reset the callstack + iReCallStack.Reset(); + + // If we don't want any call stack to be saved skip the next part + if( iAllocMaxCallStack > 0 ) + { + // Find the current thread callstack start address + TUint32 stackstart( 0 ); + TBool found( FindCurrentThreadStack( stackstart ) ); + LOGSTR3( "ATMH > stackstart: %x , find = %i", stackstart, found ); + + // Get process loaded code segments count + TInt blocksCount( iCodeblocks.Count() ); + + // Iterate through callstack to find wanted callstack addresses + // - Start: current stack address(__current_sp(): Returns the value of the + // stack pointer at the current point in your program.) + // - Stop: stack start address(Run-address of user stack) + // - Add: address length(The word size in the current system is 32 bits, which is 4 bytes) + for ( TUint32 i = __current_sp(); i < stackstart; i = i + KAddressLength )//lint !e1055 !e526 !e628 !e348 + { + TUint32 addr = (TUint32) *( (TUint32*) i ); + + // Checks is the given address in loaded code memory area. + if ( !IsAddressLoadedCode( addr ) ) + continue; + + // Iterate through array of code blocks to check if address is in code segment area + for ( TInt j = 0; j < blocksCount; j++ ) + { + // Checks if the given address is in this memory block area + if ( iCodeblocks[j].CheckAddress( addr ) ) + { + // To avoid recursive call to ReAlloc specifying granularity + // Add address to the callstack + iReCallStack[arrayCounter] = ( addr ); + arrayCounter++; + break; + } + } + // Checks if the wanted callstack items are gathered + if ( arrayCounter == KATMaxCallstackLength || + arrayCounter == iAllocMaxCallStack ) + { + LOGSTR2( "ATMH > Wanted CallStack items ready( %i )", arrayCounter ); + break; + } + } + } + + // No need to report free if the aPtr was NULL + if ( aPtr != NULL ) + { + // Reset the free callstack + iFreeCallStack.Reset(); + + // Check that logging mode is trace/trace fast so we use free call stack + // and call stack size bigger than zero + if ( (iLogOption == EATUseDefault || iLogOption == EATLogToTrace || iLogOption == EATLogToTraceFast ) + && iFreeMaxCallStack > 0 ) + { + for ( TInt i = 0; i < arrayCounter; i++ ) + { + if ( i == KATMaxFreeCallstackLength || i == iFreeMaxCallStack ) + { + break; + } + iFreeCallStack[i] = ( iReCallStack[i] ); + } + } + + // Try to remove old address from the storage server's + // leak array. If found. it's removed from the array because system frees + // old address directly in the RHeap in ReAlloc case. + if ( iLogOption == EATLogToTraceFast ) + { + ATFastLogMemoryFreed( iProcessId, (TUint32) aPtr, iFreeCallStack ); + } + else + { + iStorageServer.LogMemoryFreed( (TUint32) aPtr, iFreeCallStack ); + } + } + + // Log the memory allocation information + if ( iLogOption == EATLogToTraceFast ) + { + // Using fast logging mode. + ATFastLogMemoryAllocated( iProcessId, (TUint32) ptr, iReCallStack, aSize ); + } + else + { + // Using storage server. + error = iStorageServer.LogMemoryAllocated( (TUint32) ptr, + iReCallStack, + aSize ); + if ( KErrNone != error ) + { + switch ( error ) + { + case KErrNoMemory: + { + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::ReAlloc() - KErrNoMemory case" ); + // Check if eventhandler is active + if ( iEventHandler->IsActive() ) + { + // Cancel iEventHandler because not needed anymore + iEventHandler->Cancel(); + } + if ( iStorageServerOpen ) + { + // Close storage server + iStorageServerOpen = EFalse; + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::ReAlloc() - close iStorageServer" ); + iStorageServer.Close(); + } + break; + } + default: + { + LOGSTR2( "ATMH LogMemoryAllocated error %i", error ); + break; + } + } + } + } + } + } + + // Release the mutex + iMutex.Signal(); + + // Return pointer to the reallocated cell + return ptr; + } + +#endif // __WINS__ + +// ----------------------------------------------------------------------------- +// RAnalyzeToolMainAllocator::Compress() +// The function frees excess committed space from the top of the heap. +// The size of the heap is never reduced below the minimum size +// specified during creation of the heap. +// ----------------------------------------------------------------------------- +// +TInt RAnalyzeToolMainAllocator::Compress() + { + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::Compress()" ); + + // Acquire the mutex + iMutex.Wait(); + + // Compress the memory using original allocator + TInt compress = iAllocator->Compress(); + + // Release the mutex + iMutex.Signal(); + + // Return the space reclaimed + return compress; + } + +// ----------------------------------------------------------------------------- +// RAnalyzeToolMainAllocator::Reset() +// Frees all allocated cells on this heap. +// ----------------------------------------------------------------------------- +// +void RAnalyzeToolMainAllocator::Reset() + { + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::Reset()" ); + + // Acquire the mutex + iMutex.Wait(); + + // Reset the memory using original allocator + iAllocator->Reset(); + + // Release the mutex + iMutex.Signal(); + } + +// ----------------------------------------------------------------------------- +// RAnalyzeToolMainAllocator::AllocSize() +// Gets the number of cells allocated on this heap, and +// the total space allocated to them. +// ----------------------------------------------------------------------------- +// +TInt RAnalyzeToolMainAllocator::AllocSize( TInt& aTotalAllocSize ) const + { + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::AllocSize()" ); + + // Acquire the mutex + iMutex.Wait(); + + // Acquire the memory information using original allocator + TInt size = iAllocator->AllocSize( aTotalAllocSize ); + + // Release the mutex + iMutex.Signal(); + + // Return the number of cells allocated on this heap. + return size; + } + +// ----------------------------------------------------------------------------- +// RAnalyzeToolMainAllocator::Available() +// Gets the total free space currently available on the heap and the +// space available in the largest free block. The space available +// represents the total space which can be allocated. Note that +// compressing the heap may reduce the total free space available +// and the space available in the largest free block. +// ----------------------------------------------------------------------------- +// +TInt RAnalyzeToolMainAllocator::Available( TInt& aBiggestBlock ) const + { + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::Available()" ); + + // Acquire the mutex + iMutex.Wait(); + + // Acquire the memory information using original allocator + TInt available = iAllocator->Available( aBiggestBlock ); + + // Release the mutex + iMutex.Signal(); + + // Return the total free space currently available on the heap + return available; + } + +// ----------------------------------------------------------------------------- +// RAnalyzeToolMainAllocator::AllocLen() +// Gets the length of the available space in the specified +// allocated cell. +// ----------------------------------------------------------------------------- +// +TInt RAnalyzeToolMainAllocator::AllocLen( const TAny* aCell ) const + { + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::AllocLen()" ); + + // Acquire the mutex + iMutex.Wait(); + + // Acquire the memory information using original allocator + TInt len = iAllocator->AllocLen( aCell ); + + // Release the mutex + iMutex.Signal(); + + // Return the length of the available space in the allocated cell. + return len; + } + +// ----------------------------------------------------------------------------- +// RAnalyzeToolMainAllocator::DebugFunction() +// Invocates specified debug funtionality. +// ----------------------------------------------------------------------------- +// +TInt RAnalyzeToolMainAllocator::DebugFunction( TInt aFunc, TAny* a1, TAny* a2 ) + { + LOGSTR2( "ATMH RAnalyzeToolMainAllocator::DebugFunction() %i", aFunc ); + + // Acquire the mutex + iMutex.Wait(); + + // Invocate debug funtion using original allocator + TInt debug = iAllocator->DebugFunction( aFunc, a1, a2 ); + + switch( aFunc ) + { + case EMarkEnd: + { + // Disables the __UHEAP_MARKEND macro + LOGSTR1( "ATMH __UHEAP_MARKEND macro called" ); + if ( debug > 0 ) + { + LOGSTR2( "ATMH __UHEAP_MARKEND detects leaks: %d", debug ); + // Because there is leaks the alloc panic will occur but + // lets return a zero to pretend that everything is OK + debug = 0; + } + } + break; + + default: + { + } + break; + } + + // Release the mutex + iMutex.Signal(); + + // Return information of the debug function success + return debug; + } + +// ----------------------------------------------------------------------------- +// RAnalyzeToolMainAllocator::RemoveKilledThread() +// Remove killed thread from threads array. +// ----------------------------------------------------------------------------- +// +void RAnalyzeToolMainAllocator::RemoveKilledThread( const TUint aThreadId ) + { + LOGSTR2( "ATMH RAnalyzeToolMainAllocator::RemoveKilledThread(%i)", + aThreadId ); + + // Acquire the mutex + iMutex.Wait(); + + // Iterate through array of threads to remove current thread + TInt count( iThreadArray.Count() ); + LOGSTR2( "ATMH > iThreadArray.Count() %i", count ); + + for ( TInt i = 0; i < count; i++ ) + { + // Check if this is current thread + if ( iThreadArray[ i ].Match( aThreadId ) ) + { + // Remove the thread + iThreadArray.Remove( i ); + LOGSTR1( "ATMH > thread removed" ); + break; + } + } + + // Release the mutex + iMutex.Signal(); + } +// ----------------------------------------------------------------------------- +// RAnalyzeToolMainAllocator::Extension_() +// Extension function +// ----------------------------------------------------------------------------- +// +TInt RAnalyzeToolMainAllocator::Extension_( TUint aExtensionId, TAny*& a0, + TAny* a1) + { + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::Extension_()" ); + + // Acquire the mutex + iMutex.Wait(); + + // Invocate extension funtion using original allocator + TInt ext = RAllocator::Extension_( aExtensionId, a0, a1 ); + + // Release the mutex + iMutex.Signal(); + + // Return information of the extension function success + return ext; + } + +// ----------------------------------------------------------------------------- +// RAnalyzeToolMainAllocator::LogProcessInformation() +// Retrieve and log the process initial information +// ----------------------------------------------------------------------------- +// +void RAnalyzeToolMainAllocator::LogProcessInformation( const TFileName aFileName, + TUint32 aLogOption, TUint32 aIsDebug ) + { + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::LogProcessInformation()" ); + + // Create local variable and retrieve the process information + TProcessIdentityParamsBuf params; + params().iProcessId = iProcessId; + params().iThreadId = RThread().Id().operator TUint(); + TInt error = iAnalyzeTool.GetProcessInfo( params ); + + LOGSTR2( "ATMH GetProcessInfo %i error", error ); + + if ( KErrNone == error ) + { + LOGSTR2( "ATMH Process %i", iProcessId ); + + // Store stack start address + LOGSTR2( "ATMH Thread stack address: %x", params().iStackAddress ); + 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 + if ( iStorageServerOpen || iLogOption == EATLogToTraceFast ) + { + if ( iLogOption == EATLogToTraceFast ) + { + // Using fast logging mode. + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::LogProcessInformation() - ATFastLogProcessStarted() #1" ); + ATFastLogProcessStarted( params().iProcessName, iProcessId, aIsDebug ); + } + else + { + // Using storage server. + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::LogProcessInformation() - iStorageServerOpen #1" ); + error = iStorageServer.LogProcessStarted( + aFileName, + params().iProcessName, + iProcessId, + aLogOption, + aIsDebug ); + } + } + + LOGSTR2( "ATMH LogProcessStarted error %i", error ); + + // Iterate through process codesegments + for( TInt i = 0; i < params().iCodesegCount; i++ ) + { + // Create local variable and retrieve codesegment info + TCodesegInfoBuf codeinfo; + codeinfo().iProcessId = iProcessId; + codeinfo().iIndex = i; + error = iAnalyzeTool.GetCodesegInfo( codeinfo ); + + LOGSTR2( "ATMH GetCodesegInfo error %i", error ); + if ( KErrNone == error ) + { + // Don't log AnalyzeTool libraries + if ( 0 != codeinfo().iFullName.CompareC( KMemoryHook ) && + 0 != codeinfo().iFullName.CompareC( KStorageServer ) ) + { + // Log the loaded codesegment(s) + if ( iStorageServerOpen || iLogOption == EATLogToTraceFast ) + { + if ( iLogOption == EATLogToTraceFast ) + { + // Using fast logging mode. + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::LogProcessInformation() - ATFastLogDllLoaded() #2" ); + ATFastLogDllLoaded( iProcessId, + codeinfo().iFullName, + codeinfo().iRunAddress, + codeinfo().iRunAddress + codeinfo().iSize ); + } + else + { + // Using storage server. + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::LogProcessInformation() - iStorageServerOpen #2" ); + error = iStorageServer.LogDllLoaded( + codeinfo().iFullName, + codeinfo().iRunAddress, + codeinfo().iRunAddress + codeinfo().iSize ); + } + } + + LOGSTR2( "ATMH LogDllLoaded error %i", error ); + + // Check that everything is OK + if ( KErrNone == error ) + { + // Append the codesegment to the array + error = iCodeblocks.Append( + TCodeblock( codeinfo().iRunAddress, + codeinfo().iSize, + codeinfo().iFullName ) ); + LOGSTR2( "ATMH Append error %i", error ); + } + } + } + } + + // Iterate through process dynamic codesegments + for ( TInt i = 0; i < params().iDynamicCount; i++ ) + { + // Create local variable and retrieve codesegment info + TLibraryInfoBuf info; + info().iProcessId = iProcessId; + info().iIndex = i; + 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 ) + { + // Using fast logging mode. + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::LogProcessInformation() - - ATFastLogDllLoaded()#3" ); + ATFastLogDllLoaded( iProcessId, + info().iLibraryName, + info().iRunAddress, + info().iRunAddress + info().iSize ); + } + else + { + // Using storage server. + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::LogProcessInformation() - iStorageServerOpen #3" ); + error = iStorageServer.LogDllLoaded( + info().iLibraryName, + info().iRunAddress, + info().iRunAddress + info().iSize ); + } + } + + + LOGSTR2( "ATMH LogDllLoaded error %i", error ); + + if ( KErrNone == error ) + { + // Append the codesegment to the array + error = iCodeblocks.Append( + TCodeblock( info().iRunAddress, + info().iSize, info().iLibraryName ) ); + LOGSTR2( "ATMH Append error %i", error ); + } + } + } + } + } + +// ----------------------------------------------------------------------------- +// RAnalyzeToolMainAllocator::FindCurrentThreadStack() +// Find the current thread which is using the heap +// ----------------------------------------------------------------------------- +// +TBool RAnalyzeToolMainAllocator::FindCurrentThreadStack( TUint32& aStackStart ) + { + LOGSTR2( "ATMH RAnalyzeToolMainAllocator::FindCurrentThreadStack(), count( %i )", + iThreadArray.Count() ); + + // Flag for indicating that right thread has been found + TBool found( EFalse ); + // If threre is only one thread it must be the right thread + if ( iThreadArray.Count() == KThreadCount ) + { + if ( !iThreadArray[ 0 ].ThreadStackStart( aStackStart ) ) + { + // This MUST BE the right thread + //__ASSERT_ALWAYS( EFalse, AssertPanic( ECantFindRightThread ) ); + } + else if ( iThreadArray[ 0 ].ThreadStackStart( aStackStart ) ) + { + found = ETrue; + } + } + else + { + // Iterate through array to find right thread + TInt count = iThreadArray.Count(); + + for ( TInt i = 0; i < count; i++ ) + { + // Check if this is the right thread + if ( iThreadArray[ i ].ThreadStackStart( aStackStart ) ) + { + // Right thread found. Mark the flag + found = ETrue; + break; + } + } + // If right thread was not found the panic must be raised + if ( !found ) + { + //__ASSERT_ALWAYS( EFalse, AssertPanic( ECantFindRightThread ) ); + } + } + return found; + } + +// ----------------------------------------------------------------------------- +// RAnalyzeToolMainAllocator::InstallEventHandler() +// Installs the eventhandler, if possible +// ----------------------------------------------------------------------------- +// +void RAnalyzeToolMainAllocator::InstallEventHandler() + { + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::InstallEventHandler()" ); + + // Active eventhalder is not active, trying to start it + if ( NULL != CActiveScheduler::Current() ) + { + iEventHandler->Start(); + } + } + +// End of File diff -r d27dfa8884ad -r da2cedce4920 analyzetool/dynamicmemoryhook/src/analyzetoolmemoryallocator.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/dynamicmemoryhook/src/analyzetoolmemoryallocator.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,71 @@ +/* +* 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 RAnalyzeToolMemoryAllocator. +* +*/ + + +#include "analyzetoolmemoryallocator.h" +#include "analyzetoolpanics.pan" +#include "atlog.h" + +// ----------------------------------------------------------------------------- +// RAnalyzeToolMemoryAllocator::RAnalyzeToolMemoryAllocator() +// C++ default constructor. +// ----------------------------------------------------------------------------- +// +RAnalyzeToolMemoryAllocator::RAnalyzeToolMemoryAllocator( TBool aNotFirst ) : + RAllocator(), + iNotFirst( aNotFirst )/*, + iStorageServerOpen( EFalse )*/ + { + LOGSTR1( "ATMH RAnalyzeToolMemoryAllocator::RAnalyzeToolMemoryAllocator()" ); + + // Acquire the original allocator + iAllocator = &User::Allocator(); + + // Set memory model zero + iMemoryModel = 0; + } + +// ----------------------------------------------------------------------------- +// RAnalyzeToolMemoryAllocator::~RAnalyzeToolMemoryAllocator() +// Destructor. +// ----------------------------------------------------------------------------- +// +RAnalyzeToolMemoryAllocator::~RAnalyzeToolMemoryAllocator() + { + LOGSTR1( "ATMH RAnalyzeToolMemoryAllocator::~RAnalyzeToolMemoryAllocator()" ); + + // Call switching orinigal allocator back. + // Just in case, if uninstall was not called. + SwitchOriginalAllocator(); + } + +// ----------------------------------------------------------------------------- +// RAnalyzeToolMemoryAllocator::SwitchOriginalAllocator() +// Switches original allocator in use if not already. +// ----------------------------------------------------------------------------- +// +void RAnalyzeToolMemoryAllocator::SwitchOriginalAllocator() + { + LOGSTR1( "ATMH RAnalyzeToolMemoryAllocator::SwitchOriginalAllocator()" ); + + if ( iAllocator != &User::Allocator() ) + { + User::SwitchAllocator( iAllocator ); + } + } + +// End of File diff -r d27dfa8884ad -r da2cedce4920 analyzetool/dynamicmemoryhook/src/codeblock.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/dynamicmemoryhook/src/codeblock.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,62 @@ +/* +* 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 TCodeblock. +* +*/ + + +#include "codeblock.h" +#include "atlog.h" + +// ----------------------------------------------------------------------------- +// TCodeblock::TCodeblock +// C++ default constructor. +// ----------------------------------------------------------------------------- +// +TCodeblock::TCodeblock( TLinAddr aRunAddress, + TUint32 aSize, + TBuf8& aName ) : + iStartAddress( aRunAddress ), + iEndAddress( aRunAddress + aSize ) + { + LOGSTR3( "ATMH TCodeblock::TCodeblock() %x - %x", iStartAddress, iEndAddress ); + iName.Copy( aName ); + } + +// ----------------------------------------------------------------------------- +// TCodeblock::CheckAddress +// Checks if the given address is in this memory block area +// ----------------------------------------------------------------------------- +// +TBool TCodeblock::CheckAddress( TUint32 aAddress ) + { + if ( iStartAddress <= aAddress && aAddress <= iEndAddress ) + { + return ETrue; + } + return EFalse; + } + +// ----------------------------------------------------------------------------- +// TCodeblock::Match +// Matches if the given parameters represents this memory block +// ----------------------------------------------------------------------------- +// +TBool TCodeblock::Match( TBuf8& aName ) + { + LOGSTR1( "ATMH TCodeblock::Match()" ); + return ( 0 == iName.CompareF( aName ) ) ? ETrue : EFalse; + } + +// End of File diff -r d27dfa8884ad -r da2cedce4920 analyzetool/dynamicmemoryhook/src/customuser.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/dynamicmemoryhook/src/customuser.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,518 @@ +/* +* 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 +#include +#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 + +#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 + +// 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 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 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 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 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 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 msg; + msg.Copy( KIncorrectTextTrace ); + msg.Append( KIncorrectText ); + TBuf 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 diff -r d27dfa8884ad -r da2cedce4920 analyzetool/dynamicmemoryhook/src/threadstack.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/dynamicmemoryhook/src/threadstack.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,76 @@ +/* +* 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 TThreadStack. +* +*/ + + +#include "threadstack.h" +#include "atlog.h" + +// ----------------------------------------------------------------------------- +// TThreadStack::TThreadStack() +// C++ default constructor. +// ----------------------------------------------------------------------------- +// +TThreadStack::TThreadStack( TThreadId aId, TUint32 aStackStart ) : + iId( aId ), + iStackStart( aStackStart ) + { + LOGSTR2( "ATMH TThreadStack::TThreadStack() aStackStart: %i", aStackStart ); + } + +// ----------------------------------------------------------------------------- +// TThreadStack::ThreadStackStart() +// Checks if this is the current thread and if this is the current +// thread assings value to the given parameter +// ----------------------------------------------------------------------------- +// +TBool TThreadStack::ThreadStackStart( TUint32& aStackStart ) + { + LOGSTR1( "ATMH TThreadStack::ThreadStackStart"); + + if ( RThread().Id() == iId ) + { + aStackStart = iStackStart; + return ETrue; + } + else + { + aStackStart = 0; + return EFalse; + } + } + +// ----------------------------------------------------------------------------- +// TThreadStack::Match() +// Checks if this is the the current thread. +// ----------------------------------------------------------------------------- +// +TBool TThreadStack::Match( const TUint aThreadId ) + { + LOGSTR2( "ATMH TThreadStack::Match( %d )", aThreadId ); + + if ( aThreadId != 0 ) + { + LOGSTR2( "ATMH > iId.operator TUint() = %d", iId.operator TUint() ); + return ( aThreadId == iId.operator TUint() ) ? ETrue : EFalse; + } + else + { + return ( RThread().Id() == iId ) ? ETrue : EFalse; + } + } + +// End of File diff -r d27dfa8884ad -r da2cedce4920 analyzetool/envpatcher/EnvPatcher.pl --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/envpatcher/EnvPatcher.pl Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,544 @@ +# +# 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: +# Environment Patcher - Patches older S60 SDKs for supporting +# tricks in newer platforms +# + + +require v5.6.1; + +use File::Copy; +use strict; + +# check amount of commandline options is valid +if (@ARGV != 1) +{ + print "Usage: EnvPatcher \n"; + exit 1; +} + + +# get epocroot and convert, convert \ -> / +(my $epocroot = $ARGV[0]) =~ s{\\}{/}g; + +# remove any trailing forward slashes +$epocroot =~ s/\/$//; + + +# create variables for paths +my $e32toolsdir = $epocroot."/epoc32/tools"; +my $e32includedir = $epocroot."/epoc32/include"; +my $e32includeoemdir = $e32includedir."/oem"; +my $platformpathspath = $e32includedir."/platform_paths.hrh"; +my $domainplatformpathspath = $e32includedir."/domain/osextensions/platform_paths.hrh"; +my $mmppmpath = $e32toolsdir."/mmp.pm"; +my $pathutlpmpath = $e32toolsdir."/pathutl.pm"; +my $prepfilepmpath = $e32toolsdir."/prepfile.pm"; + +# variables for hacked content +my $dependshack = "\t\t\tif (/^DEPENDS\$/o) {\r\n\t\t\t\tnext LINE; # Ignore DEPENDS keyword, not needed by ABLD\r\n\t\t\t}\r\n"; +my $smpsafehack = "\t\tif (/^SMPSAFE\$/o) {\r\n\t\t\tnext LINE; # Ignore SMPSAFE keyword, not needed by older environments\r\n\t\t}\r\n"; +my $forwardslashhack = "\t\t# EnvPatcher forwardslash hack begins\r\n\t\t\$_=~s{/}{\\\\}g; # convert all forward slashes to backslashes\r\n\t\t# EnvPatcher forwardslash hack ends\r\n\r\n"; +my $coreibyexportsupport = "\r\n// Following definition is used for exporting tools and stubs IBY files to\r\n// Core image.\r\n#define CORE_IBY_EXPORT_PATH(path,exported) /epoc32/rom/include/##exported\r\n"; + + +# check epoc32\tools exists +unless (-d $e32toolsdir) +{ + print "$e32toolsdir not found, please check valid epocroot has been given!\n"; + exit 1; +} + +# check epoc32\include exists +unless (-d $e32includedir) +{ + print "$e32includedir not found, please check valid epocroot has been given!\n"; + exit 1; +} + + +# create epoc32\include\oem if it does not exist +unless (-d $e32includeoemdir) +{ + mkdir $e32includeoemdir or die; + print "Missing directory $e32includeoemdir created succesfully.\n"; +} + + +# check if epoc32\include\domain\osextensions\platform_paths.hrh exists +if (-e $domainplatformpathspath) +{ + # show an error if the file does not have any platform macros + unless (string_exists_in_file($domainplatformpathspath, "OS_LAYER_SYSTEMINCLUDE")) + { + print "ERROR: $domainplatformpathspath does not have SF macros.\n"; + print "Please check your environment, if you have S60 3.2 OEM or newer, please get the latest version!\n"; + exit 2; + } +} + + +# check if epoc32\include\platform_paths.hrh exists +if (-e $platformpathspath) +{ + print "$platformpathspath already exists, not checking it.\n"; +} +else +{ + # create the file missing file + create_default_platform_paths_hrh(); + print "Missing file $platformpathspath created succesfully.\n"; +} + + +# check if CORE_IBY_EXPORT_PATH macro exist in the platform_paths.hrh +unless (string_exists_in_file($platformpathspath, "CORE_IBY_EXPORT_PATH")) +{ + # read content of the platform_paths.hrh + my @filecontent = read_file_to_array($platformpathspath); + + my $match_found = 0; + my $i = 0; + my $match_found_pos = 0; + + # find the position where the include guards start (this should be a safe position) + foreach (@filecontent) + { + if ($_ =~ /#define PLATFORM_PATHS_HRH/) + { + $match_found = 1; + $match_found_pos = $i; + last; + } + + $i++; + } + + if ($match_found) + { + # insert the patched content to the file + splice(@filecontent, $match_found_pos+1, 0, $coreibyexportsupport); + + # write the modified array to the file + write_file_from_array($platformpathspath, @filecontent); + + print "Platform_paths.hrh updated to support CORE_IBY_EXPORT_PATH macro.\n"; + } + else + { + print "WARNING: $platformpathspath is corrupted or not supported!\n"; + } +} + + +# check if epoc32\tools\mmp.pm exists +if (-e $mmppmpath) +{ + # check if DEPENDS keyword already exists in the file + if (string_exists_in_file($mmppmpath, "DEPENDS")) + { + print "The SDK can already handle DEPENDS keyword in a MMP file.\n"; + } + else + { + # read content of the mmp.pm file + my @filecontent = read_file_to_array($mmppmpath); + + my $match_found = 0; + my $i = 0; + my $match_found_pos = 0; + + # loop through the array to find the correct place + foreach (@filecontent) + { + if ($_ =~ /Unrecognised Resource Keyword/) + { + $match_found = 1; + $match_found_pos = $i; + last; + } + + $i++; + } + + if ($match_found) + { + # insert the patched content to the file + splice(@filecontent, $match_found_pos-1, 0, $dependshack); + + # write the modified array to the file + write_file_from_array($mmppmpath, @filecontent); + + print "Mmp.pm patched with DEPENDS keyword hack.\n"; + } + else + { + print "ERROR: Unable to find correct place from $mmppmpath for patching!\n"; + print "Your SDK environment probably is not supported by this script!\n"; + exit(2); + } + } + + # check if SMPSAFE keyword already exists in the file + if (string_exists_in_file($mmppmpath, "SMPSAFE")) + { + print "The SDK can already handle SMPSAFE keyword in a MMP file.\n"; + } + else + { + # read content of the mmp.pm file + my @filecontent = read_file_to_array($mmppmpath); + + my $match_found = 0; + my $i = 0; + my $match_found_pos = 0; + + # loop through the array to find the correct place + foreach (@filecontent) + { + if ($_ =~ /Unrecognised Keyword/) + { + $match_found = 1; + $match_found_pos = $i; + last; + } + + $i++; + } + + if ($match_found) + { + # insert the patched content to the file + splice(@filecontent, $match_found_pos, 0, $smpsafehack); + + # write the modified array to the file + write_file_from_array($mmppmpath, @filecontent); + + print "Mmp.pm patched with SMPSAFE keyword hack.\n"; + } + else + { + print "ERROR: Unable to find correct place from $mmppmpath for patching!\n"; + print "Your SDK environment probably is not supported by this script!\n"; + exit(2); + } + } +} +else +{ + print "WARNING: $mmppmpath not found, this environment is not supported!\n"; +} + + +# check if epoc32\tools\pathutl.pm exists +if (-e $pathutlpmpath) +{ + # check if "sub Path_Norm" already exists in the pathutil.pm file + # if it does not exists, then we need to patch prepfile.pm + if (string_exists_in_file($pathutlpmpath, "sub Path_Norm")) + { + print "The SDK is non Symbian OS 9.1, no need to add forward slash hack.\n"; + } + else + { + # check if prepfile.pm has already been patched + if (string_exists_in_file($prepfilepmpath, "EnvPatcher forwardslash hack")) + { + print "The SDK has already been patched with forwardslash hack.\n"; + } + else + { + # read content of the prepfile.pm file + my @filecontent = read_file_to_array($prepfilepmpath); + + my $match_found = 0; + my $i = 0; + my $match_found_pos = 0; + + # loop through the array to find the correct place + foreach (@filecontent) + { + if ($_ =~ /# skip blank lines/) + { + $match_found = 1; + $match_found_pos = $i; + last; + } + + $i++; + } + + if ($match_found) + { + # insert the patched content to the file + splice(@filecontent, $match_found_pos+6, 0, $forwardslashhack); + + # write the modified array to the file + write_file_from_array($prepfilepmpath, @filecontent); + + print "Prepfile.pm patched with forward slash hack.\n"; + } + else + { + print "ERROR: Unable to find correct place from $prepfilepmpath for patching!\n"; + print "Your SDK environment probably is not supported by this script!\n"; + exit(2); + } + } + } +} +else +{ + print "WARNING: $pathutlpmpath not found, this environment is not supported!\n"; +} + + + +# checks if string exists in the file +sub string_exists_in_file +{ + my $filepath = $_[0]; + my $findstring = $_[1]; + my $match_found = 0; + + open(FILE, "<", $filepath) or die "Failed to open $filepath for reading!"; + + # loop through the file for occurances + while () + { + if ($_ =~ /$findstring/) + { + $match_found = 1; + last; + } + } + + close FILE; + + return $match_found; +} + + +# reads lines from a file to an array +sub read_file_to_array +{ + my $filepath = $_[0]; + + open(FILE, "<", $filepath) or die "Failed to open $filepath for reading!"; + my @data = ; + close FILE; + + return(@data); +} + + +# writes lines from an array to a file +sub write_file_from_array +{ + my ($filepath, @data) = @_; + + # take a backup of the file + copy ($filepath, $filepath."EnvPatcher") or die "Cannot take backup of $filepath to $filepath.EnvPatcher"; + + open(FILE, ">", $filepath) or die "Failed to open $filepath for writing!"; + + # write the array to file + foreach my $line (@data) + { + print FILE "$line"; + } + + close FILE; +} + +sub create_default_platform_paths_hrh +{ + # the file does not exist, so create the missing file + open(FILE, ">", $platformpathspath) or die "Failed to open $platformpathspath for writing!\n"; + + print FILE < thus they are first. +*/ +#define APP_LAYER_SYSTEMINCLUDE SYSTEMINCLUDE /epoc32/include /epoc32/include/oem + +/** +* This define statements defines the SYSTEMINCLUDE-line, which is intended to be +* used in the mmp-files that are part of the middleware-layer. It includes all +* the needed directories from the /epoc32/include, that are valid ones for the +* middleware-layer components. +*/ +#define MW_LAYER_SYSTEMINCLUDE SYSTEMINCLUDE /epoc32/include /epoc32/include/oem + +/** +* This define statements defines the SYSTEMINCLUDE-line, which is intended to be +* used in the mmp-files that are part of the osextensions-layer. It includes all +* the needed directories from the /epoc32/include, that are valid ones for the +* os-layer components. +*/ +#define OS_LAYER_SYSTEMINCLUDE SYSTEMINCLUDE /epoc32/include /epoc32/include/oem + + +// Below statement is Deprecated and the OS_LAYER_SYSTEMINCLUDE-macro has to be +// used. +#define OSEXT_LAYER_SYSTEMINCLUDE OS_LAYER_SYSTEMINCLUDE + +/** +* This define statements defines the SYSTEMINCLUDE-line, which is intended to be +* used in the mmp-files that are part of the os-layer. This is intended +* to be only used by those components which need to use in their mmp-file either +* kern_ext.mmh or nkern_ext.mmh. Reason is that those +* 2 files already contain the /epoc32/include as system include path. +* +*/ +#define OS_LAYER_KERNEL_SYSTEMINCLUDE SYSTEMINCLUDE /epoc32/include/oem + + +// Below statement is Deprecated and the OS_LAYER_KERNEL_SYSTEMINCLUDE-macro +// has to be used. +#define OSEXT_LAYER_KERNEL_SYSTEMINCLUDE OS_LAYER_KERNEL_SYSTEMINCLUDE + +/** +**************************************************************************** +* Definitions that also define the paths to the layer specific source directories. +**************************************************************************** +*/ +/** +* The below 3 macros define the paths to the layer-specific source dirs. +* See usage on top of this hrh-file, these are used the same way as +* for instance the OS_LAYER_DOMAIN_EXPORT_PATH +* Deprecated: is not allowed to be using in Symbian Foundation +*/ +#define APP_LAYER_SOURCE_PATH(rest) /s60/app/##rest +#define MW_LAYER_SOURCE_PATH(rest) /s60/mw/##rest +#define OSEXT_LAYER_SOURCE_PATH(rest) /s60/osext/##rest + +/** +**************************************************************************** +* Definitions to export IBY files to different folders where they will be taken +* to ROM image +**************************************************************************** +*/ +// Following definition is used for exporting tools and stubs IBY files to +// Core image. +#define CORE_IBY_EXPORT_PATH(path,exported) /epoc32/rom/include/##exported + +/** +* --------------------------------------- +* Macros for Configuration tool migration. +* The below macros define the location under epoc32, where the confml +* (Configuration Markup Language) and crml (Central Repository Markup Language) +* files should be exported. +* --------------------------------------- +*/ +#define CONFML_EXPORT_PATH(file,category) /epoc32/rom/config/confml_data/##category##/##file +#define CRML_EXPORT_PATH(file,category) /epoc32/rom/config/confml_data/##category##/##file +#define GCFML_EXPORT_PATH(file,category) /epoc32/rom/config/confml_data/##category##/##file +#define CONFML_CONFIG_EXPORT_PATH(file,category) /epoc32/rom/config/confml_data/##category##/config/##file + +#define APP_LAYER_CONFML(exported) CONFML_EXPORT_PATH(exported,s60) +#define APP_LAYER_CRML(exported) CRML_EXPORT_PATH(exported,s60) +#define APP_LAYER_GCFML(exported) GCFML_EXPORT_PATH(exported,s60) +#define APP_LAYER_CONFML_CONFIG(exported) CONFML_CONFIG_EXPORT_PATH(exported,s60) + +#define MW_LAYER_CONFML(exported) CONFML_EXPORT_PATH(exported,s60) +#define MW_LAYER_CRML(exported) CRML_EXPORT_PATH(exported,s60) +#define MW_LAYER_GCFML(exported) GCFML_EXPORT_PATH(exported,s60) +#define MW_LAYER_CONFML_CONFIG(exported) CONFML_CONFIG_EXPORT_PATH(exported,s60) + +// Deprecate: Use the OS_LAYER_* macros instead of OSEXT_LAYER_* +#define OSEXT_LAYER_CONFML(exported) CONFML_EXPORT_PATH(exported,s60) +#define OSEXT_LAYER_CRML(exported) CRML_EXPORT_PATH(exported,s60) +#define OSEXT_LAYER_GCFML(exported) GCFML_EXPORT_PATH(exported,s60) +#define OSEXT_LAYER_CONFML_CONFIG(exported) CONFML_CONFIG_EXPORT_PATH(exported,s60) +#define OS_LAYER_CONFML(exported) CONFML_EXPORT_PATH(exported,s60) +#define OS_LAYER_CRML(exported) CRML_EXPORT_PATH(exported,s60) +#define OS_LAYER_GCFML(exported) GCFML_EXPORT_PATH(exported,s60) +#define OS_LAYER_CONFML_CONFIG(exported) CONFML_CONFIG_EXPORT_PATH(exported,s60) + +#endif // end of PLATFORM_PATHS_HRH + +ENDOFTHEFILE + + close FILE; +} diff -r d27dfa8884ad -r da2cedce4920 analyzetool/envpatcher/ReadMe.txt --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/envpatcher/ReadMe.txt Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,46 @@ +Environment Patcher v1.0.1 +========================== + +Updated: 12th November 2009 + + +Introduction: +------------- +This tool can be used to patch your S60 SDK environment so that the tricks and +macros introduced in the latest SDKs can be used in a public SDK and older +OEM releases. + +This tool can perform the following tasks: +- Adds support for forward slashes in paths in bld.inf/.mmp files in S60 3.0 +- Removes an unncessary warning about DEPENDS and SMPSAFE resource keywords in + an .mmp file +- Creates a missing epoc32\include\platform_paths.hrh file for supporting + platform macros introduced since S60 3.2 OEM and Symbian Foundation releases +- Modifies epoc32\include\platform_paths.hrh for missing macros +- Creates a missing epoc32\include\oem directory to suppress a possible warning + + +Usage: +------ +EnvPatcher.pl + +Where EPOCROOT is the path to the root of the SDK, for example: + EnvPatcher.pl c:\Symbian\9.1\S60_3rd_MR + EnvPatcher.pl z:\ + + +Requirements: +------------- +- S60 SDK (public or OEM), version 3.0 or newer +- Perl 5.6.1 or newer + + + + +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". diff -r d27dfa8884ad -r da2cedce4920 analyzetool/group/ReleaseNotes_AnalyzeTool.txt --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/group/ReleaseNotes_AnalyzeTool.txt Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,136 @@ +=============================================================================== + +RELEASE NOTES - ANALYZETOOL v1.9.1 +RELEASED 29th April 2010 + +SUPPORTS SYMBIAN^1+ + +=============================================================================== + +Product Description: +==================== +AnalyzeTool is a dynamic test tool that is used for testing Symbian software +for memory and resource leaks and pinpointing the leaks from the source code. + +Main Features: +============== +- Pinpoints memoryleaks from target hardware and emulator to source code lines +- Discovers resource leaks from processes +- Command line interface and Carbide.c++ Extension + +=============================================================================== + +What's New in v1.9.1 +==================== +- Change: Removed Avkon and Console UI's to simplify the maintenance of the + tool +- Change: Middleware layer dependencies removed so AnalyzeTool can be now used + also in OS layer builds +- Fix: Move all binaries to ROM instead of ROFS to avoid ROM build + dependencies issues in hooked components + +=============================================================================== + +Installation Notes: +=================== +AnalyzeTool is typically preinstalled on ROM. If not, it can be added to the +ROM with the .iby file. Alternatively, the .sis file can be found under the sis- +directory, but the user need to sign it with their own developer certificate. +In Nokia R&D environment, you can use directly the R&D-signed .sis file under the +internal\sis directory. + +When signing with own developer certificate, the following capabilities are +needed: + ReadDeviceData + WriteDeviceData + DiskAdmin + AllFiles + SwEvent + NetworkServices + LocalServices + ReadUserData + WriteUserData + Location + UserEnvironment + CommDD + PowerMgmt + MultimediaDD + DRM + TrustedUI + ProtServ + NetworkControl + SurroundingsDD + TCB + +When builing AnalyzeTool against S60 3.0 or 3.1, you may need to patch your SDK +environment first with some fixes. For more information, please refer to the +instructions under the "envpatcher" directory. + +=============================================================================== + +System Requirements: +==================== +Basic Requirements: +- Any S60 3.x device or emulator environment + +=============================================================================== + +Compatibility Issues: +===================== +N/A + +=============================================================================== + +Known Issues: +============= +- Kernel analysis are not supported. + +- When using monitored internal data gathering mode (-mi) and hooked + application contains huge amounts of allocations AnalyzeTool? storageserver + might run out of memory to store the data. This message "Symbian error code + -4" is seen when analyzing the data file with atool.exe. Solution is to use + external / monitored external data gathering mode. + +- Switch allocator. AnalyzeTool change the application memory allocator to + AnalyzeTool own memory allocator and using the User::SwitchAllocator function + can lead to situation where the tested application does not work properly. + +- AnalyzeTool hooked QT applications becomes too slow to run. Use small size + call stack(s) and new logging mode (external -e). + +- Stif test case with AnalyzeTool can inform wrong memory leak alert. + +- AnalyzeTool overwrites functions TInt User::ProcessCritical(TCritical + aCritical) and TInt User::SetProcessCritical(TCritical aCritical), but this + works only when the function is called from hooked exe application. So if + setting critical is done from DLL (even if it's hooked with AnalyzeTool) the + overwriting does not work and the process stays set critical during the + testing. + +- If hooked application is closed by calling User::Exit() from DLL instead of + .exe application AnalyzeTool reports "abnormal process end" and can't report + proper memory leaks. + +=============================================================================== + +Version History: +================ + +Version 1.9.0 - 8th April 2010 +============================== +- Feature: Remove false positive memory leaks with better handling of global + variables +- Feature: Automatic check of correct version of dbghelp.dll for better + emulator support +- Change: HTI support removed +- Fix: SBSVS variant compilation didn't work + +=============================================================================== + +Copyright (c) 2010 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". diff -r d27dfa8884ad -r da2cedce4920 analyzetool/group/atool_stub_sis.mk --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/group/atool_stub_sis.mk Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,57 @@ +# +# 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: Stub sis makefile for Configuration UI. +# + +TARGETDIR=$(EPOCROOT)EPOC32\Data\Z\System\Install + +SISNAME=analyzeTool_stub +PKGNAME=analyzeTool_stub + +$(TARGETDIR) : + @perl -S emkdir.pl "$(TARGETDIR)" + +do_nothing : + rem do_nothing + +SISFILE=$(TARGETDIR)\$(SISNAME).sis + +$(SISFILE) : ..\sis\$(PKGNAME).pkg + makesis -s $? $@ + +# +# The targets invoked by bld... +# + +MAKMAKE : do_nothing + +RESOURCE : do_nothing + +SAVESPACE : do_nothing + +BLD : do_nothing + +FREEZE : do_nothing + +LIB : do_nothing + +CLEANLIB : do_nothing + +FINAL : $(TARGETDIR) $(SISFILE) + +CLEAN : + -erase $(SISFILE) + +RELEASABLES : + @echo $(SISFILE) \ No newline at end of file diff -r d27dfa8884ad -r da2cedce4920 analyzetool/group/bld.inf --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/group/bld.inf Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,49 @@ +/* +* 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: +* +*/ + +#include + + +#include "../commandlineengine/group/bld.inf" +#include "../staticlib/group/bld.inf" +#include "../storageserver/group/bld.inf" +#include "../kerneleventhandler/group/bld.inf" +#include "../analyzetoolcleaner/group/bld.inf" +#include "../dynamicmemoryhook/group/bld.inf" + +PRJ_EXPORTS +//../rom/analyzetool.iby CORE_IBY_EXPORT_PATH(tools,analyzetool.iby) +../rom/analyzetool_rom.iby CORE_IBY_EXPORT_PATH(tools/rom,analyzetool_rom.iby) + +/* +PRJ_MMPFILES +#ifndef SBSV2 + #ifdef MARM + gnumakefile atool_stub_sis.mk + #endif +#endif + +PRJ_EXTENSIONS +#ifdef SBSV2 + #ifdef MARM + START EXTENSION app-services/buildstubsis + OPTION SRCDIR ../sis + OPTION SISNAME analyzeTool_stub + END + #endif +#endif +*/ \ No newline at end of file diff -r d27dfa8884ad -r da2cedce4920 analyzetool/inc/atlog.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/inc/atlog.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,128 @@ +/* +* 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 of logging macros for Analyze Tool S60 modules. +* +*/ + +#ifndef __ATLOG_H__ +#define __ATLOG_H__ + +#ifdef _DEBUG +//To enable/disable logging uncomment/comment the next line +// #define LOGGING_ENABLED //Enable logging +//Uncomment next to enable logging only LOGSTR1 lines +// #define LOGGING_ENABLED_FAST //Logging only function names + +//Disable next to use file logging + #define USE_RDEBUG +#endif + +//Do not alter the code below this + +#ifdef __KERNEL_MODE__ + + #ifdef LOGGING_ENABLED + #include + #define LOGSTR1( AAA ) { Kern::Printf( AAA ); } + #define LOGSTR2( AAA, BBB ) { Kern::Printf( AAA, BBB ); } + #else + #define LOGSTR1( AAA ) + #define LOGSTR2( AAA, BBB ) + #endif + +#else // #ifdef __KERNEL_MODE__ + + #ifdef LOGGING_ENABLED + +// INCLUDES + #include + #ifdef USE_RDEBUG + #include + #endif + +// CONSTANTS + _LIT( KAtLoggingFolder, "atlog" ); + _LIT( KAtLoggingFile , "LOG.TXT" ); + #define ONE_SPACE_MARGIN _S(" ") + +// --------------------------------------------------------------------------------- +// Internal MACROS. Do not call these directly, use the External MACROS instead +// --------------------------------------------------------------------------------- + + #ifdef LOGGING_ENABLED_FAST + + #ifdef USE_RDEBUG + #define INTERNAL_LOGSTR1( AAA ) { _LIT( logdes, AAA ); RDebug::Print( logdes() ); } + #else // RFileLogger is used + #define INTERNAL_LOGSTR1( AAA ) { _LIT( logdes, AAA ); RFileLogger::Write( KAtLoggingFolder(), KAtLoggingFile(), EFileLoggingModeAppend, logdes() ); } + #endif // USE_RDEBUG + #define INTERNAL_LOGSTR2( AAA, BBB ) + #define INTERNAL_LOGSTR3( AAA, BBB, CCC ) + #define INTERNAL_LOGMEM + #define INTERNAL_LOG( AAA ) + + #else + + #ifdef USE_RDEBUG + #define INTERNAL_LOGDESC8( AAA ) { TBuf<100> tmp; if( sizeof( AAA ) < 100 ) tmp.Copy( AAA ); RDebug::Print( tmp );} + #define INTERNAL_LOGSTR1( AAA ) { _LIT( logdes, AAA ); RDebug::Print( logdes() ); } + #define INTERNAL_LOGSTR2( AAA, BBB ) { _LIT( logdes, AAA ); RDebug::Print( TRefByValue( logdes()), BBB ); } + #define INTERNAL_LOGSTR3( AAA, BBB, CCC ) { _LIT( logdes, AAA ); RDebug::Print( TRefByValue(logdes()), BBB, CCC ); } + #define INTERNAL_LOGMEM { _LIT( logdes, "Heap size: %i" ); TBuf<50> buf; TInt a; User::AllocSize( a ); buf.Format( logdes, a ); RDebug::Print( buf ); } + #define INTERNAL_LOG( AAA ) AAA + #else // RFileLogger is used + #define INTERNAL_LOGSTR1( AAA ) { _LIT( logdes, AAA ); RFileLogger::Write( KAtLoggingFolder(), KAtLoggingFile(), EFileLoggingModeAppend, logdes() ); } + #define INTERNAL_LOGSTR2( AAA, BBB ) { _LIT( logdes, AAA ); RFileLogger::WriteFormat( KAtLoggingFolder(), KAtLoggingFile(), EFileLoggingModeAppend, TRefByValue( logdes()), BBB ); } + #define INTERNAL_LOGSTR3( AAA, BBB, CCC) { _LIT( logdes, AAA ); RFileLogger::WriteFormat( KAtLoggingFolder(), KAtLoggingFile(), EFileLoggingModeAppend, TRefByValue(logdes()), BBB, CCC ); } + #define INTERNAL_LOGMEM { _LIT( logdes, "Heap size: %i" ); TMemoryInfoV1Buf info; UserHal::MemoryInfo(info); TInt freeMemory = info().iFreeRamInBytes; TBuf<50> buf; buf.Format( logdes, freeMemory ); RFileLogger::WriteFormat( KAtLoggingFolder(), KAtLoggingFile(), EFileLoggingModeAppend, buf ); } + #define INTERNAL_LOG( AAA ) AAA + #endif // USE_RDEBUG + + #endif + + #else + + #define INTERNAL_LOGSTR1( AAA ) + #define INTERNAL_LOGSTR2( AAA, BBB ) + #define INTERNAL_LOGSTR3( AAA, BBB, CCC ) + #define INTERNAL_LOGMEM + #define INTERNAL_LOG( AAA ) + + #endif + +// --------------------------------------------------------------------------------- +// External MACROS. Use these in code +// --------------------------------------------------------------------------------- +// Logging of string +// i.e.: LOGSTR1( "Whoo-haa!" ); + #define LOGSTR1( AAA ) { INTERNAL_LOGSTR1( AAA ); } + +// Logging of string + integer value +// i.e.: LOGSTR2( "CHttpd status %i:", iStatus ); + #define LOGSTR2( AAA, BBB ) { INTERNAL_LOGSTR2( AAA, BBB ); } + +// Logging of descriptor + 2 integers +// i.e.: LOGSTR3( "Jippii %i %i", val1, val2 ); + #define LOGSTR3( AAA, BBB, CCC ) { INTERNAL_LOGSTR3( AAA, BBB, CCC ); } + +// Log heap size + #define LOGMEM { INTERNAL_LOGMEM } + +// Logging variable operations + #define LOG( AAA ) INTERNAL_LOG( AAA ) + +#endif // #ifdef __KERNEL_MODE__ + +#endif // __ATLOG_H__ +// End of File diff -r d27dfa8884ad -r da2cedce4920 analyzetool/kerneleventhandler/group/atoolkerneleventhandler.mmp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/kerneleventhandler/group/atoolkerneleventhandler.mmp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,51 @@ +/* +* 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: The .mmp file for the AToolKernelEventHandler +* +*/ + +#include +#include +#include "../../symbian_version.hrh" + +TARGET atoolkerneleventhandler.ldd +TARGETTYPE ldd +CAPABILITY ALL + +SMPSAFE + +USERINCLUDE ../inc +USERINCLUDE ../../inc + +OS_LAYER_KERNEL_SYSTEMINCLUDE + +SOURCEPATH ../src + +SOURCE analyzetoolchannel.cpp +SOURCE analyzetooldevice.cpp +SOURCE analyzetooleventhandler.cpp + +LIBRARY flogger.lib +#ifdef WINSCW +LIBRARY emulator.lib + start wins + win32_headers + end +#endif // WINSCW + +#if ( SYMBIAN_VERSION_SUPPORT >= SYMBIAN_3 ) || defined(BSW_FLEXIBLE_MEMORY_MODEL) +MACRO MCL_ROBJECTIX +#endif + +// End of File diff -r d27dfa8884ad -r da2cedce4920 analyzetool/kerneleventhandler/group/bld.inf --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/kerneleventhandler/group/bld.inf Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,35 @@ +/* +* 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: +* +*/ + +#include + +PRJ_PLATFORMS +ARMV5 WINSCW + +PRJ_EXPORTS +../inc/analyzetool.h OS_LAYER_PLATFORM_EXPORT_PATH(analyzetool/analyzetool.h) +../inc/atcommon.h OS_LAYER_PLATFORM_EXPORT_PATH(analyzetool/atcommon.h) +../inc/analyzetool.inl OS_LAYER_PLATFORM_EXPORT_PATH(analyzetool/analyzetool.inl) +../inc/analyzetooltraceconstants.h OS_LAYER_PLATFORM_EXPORT_PATH(analyzetool/analyzetooltraceconstants.h) + +PRJ_MMPFILES +atoolkerneleventhandler.mmp + +PRJ_TESTMMPFILES +../internal/tsrc/group/analyzetooldevicedrivertest.mmp + + diff -r d27dfa8884ad -r da2cedce4920 analyzetool/kerneleventhandler/inc/analyzetool.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/kerneleventhandler/inc/analyzetool.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,325 @@ +/* +* 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: Declaration of the class RAnalyzeTool. +* +*/ + + +#ifndef __ANALYZETOOL_H__ +#define __ANALYZETOOL_H__ + +// INCLUDES +#include + +//Version information for command line engine. +//Tells the version of AT core componenets. +//ANALYZETOOL_CORE_VERSION_FOR_CLE 1.9.1 + +// CONSTANTS +inline TVersion KAnalyzeToolLddVersion() { return TVersion(1, 0, 1); } + +/* The name of the analyze tool device driver*/ +_LIT( KAnalyzeToolLddName, "AToolKernelEventHandler" ); + +/* The priority of AnalyzeTool Dfc */ +const TInt KAnalyzeToolThreadPriority = 27; + +/* The name of the AnalyzeTool DFC */ +_LIT8( KAnalyzeToolThreadName, "AnalyzeToolThreadDfc" ); + +/* The panic literal */ +_LIT( KClientPanic, "AnalyzeTool" ); + +//const TInt KATMaxCallstackLength = 20; + +/* The device handler panic codes */ +enum TPanic + { + EPanicRequestPending, + EPanicNoRequestPending, + EPanicUnsupportedRequest + }; + +// Size of following must be multiple of 4 bytes. + +class TMainThreadParams + { + public: + RAllocator* iAllocator; + TBool iAlone; + TUint iProcessId; + }; +typedef TPckgBuf TMainThreadParamsBuf; + +class TLibraryInfo + { + public: + TBuf8 iLibraryName; + TLinAddr iRunAddress; + TUint32 iSize; + TInt iIndex; + TUint iProcessId; + }; + +typedef TPckgBuf TLibraryInfoBuf; + +class TCodesegInfo + { + public: + TBuf8 iFullName; + TLinAddr iRunAddress; + TUint32 iSize; + TInt iIndex; + TUint iProcessId; + TInt iCodesegIndex; + TLinAddr iFileEntryPoint; + TInt iFuntionCount; + TLibraryFunction iFirstFunction; + TModuleMemoryInfo iMemoryInfo; + }; + +typedef TPckgBuf TCodesegInfoBuf; + +class TThreadParams + { + public: + TLinAddr iStackAddress; + TInt iStackSize; + TUint iThreadId; + }; + +typedef TPckgBuf TThreadParamsBuf; + +class TProcessIdentityParams + { + public: + TBuf8 iProcessName; + TInt iDynamicCount; + TInt iCodesegCount; + TUint iProcessId; + TUint iThreadId; + TLinAddr iStackAddress; + TInt iStackSize; + }; + +typedef TPckgBuf TProcessIdentityParamsBuf; + +class TLibraryEventInfo + { + public: + enum TLibraryEvent + { + ELibraryAdded = 0, + ELibraryRemoved, + EKillThread + }; + + public: + TUint iProcessId; + TBuf8 iLibraryName; + TLinAddr iRunAddress; + TUint32 iSize; + TLibraryEvent iEventType; + TUint iThreadId; + }; + +typedef TPckgBuf TLibraryEventInfoBuf; + +class TProcessHandleInfo + { + public: + TInt iProcessHandleCount; + TInt iThreadHandleCount; + TInt iIndex; + TInt iThreadCount; + TLinAddr iUserStackRunAddress; + TInt iUserStackSize; + TUint iProcessId; + }; + +typedef TPckgBuf TProcessHandleInfoBuf; + +/** +* A class for particular process's current handle count +*/ +class TATProcessHandles + { + public: + + /** The ID of the process. */ + TUint iProcessId; + + /** The number of current handles in the library. */ + TInt iCurrentHandleCount; + }; + +typedef TPckgBuf TATProcessHandlesBuf; + +class TClientCount + { + public: + + /** The count of clients */ + TInt iClientCount; + }; + +typedef TPckgBuf TClientCountBuf; + +class TATMemoryModel + { + public : + /* Memory model*/ + TUint32 iMemoryModel; + }; +typedef TPckgBuf TATMemoryModelBuf; + +// CLASS DECLARATION + +/** +* The user-side handle to a logical channel which provides functions to +* open a channel and to make requests to a analyze tool device driver. +*/ + +class RAnalyzeTool : public RBusLogicalChannel + { + + public: + + /** Enumeration of supported functions */ + enum TBasicAnalyzerControl + { + EGetProcessInfo = 0, /* The process information */ + EGetCodesegInfo, /* The codesegment information */ + EGetLibraryInfo, /* The library information */ + EGetDynamicInfo, /* The count of dynamic code in the process */ + ELibraryEvent, /* Subscribe events from library events */ + ECancelLibraryEvent, /* Cancel subscribetion of library events */ + ECurrentClientCount, /* The count of clients in device driver */ + EMainThreadAlloctor, + EThreadStack, + EGetProcessHandle, /* Gets process global handles info*/ + EGetCurrentHandles, /* Get a process's current handle count */ + EGetMemoryModel + }; + +#ifndef __KERNEL_MODE__ + + /** + * Opens a handle to a logical channel. + * @return TInt Returns KErrNone, if successful or otherwise + one of the other system-wide error codes + */ + inline TInt Open(); + + /** + * Acquires process information. + * @param aProcessIdentityParams The process information which + is filled by the device driver + * @return TInt Returns KErrNone, if successful + otherwise one of the other system-wide error codes + */ + inline TInt GetProcessInfo( + TProcessIdentityParamsBuf& aProcessIdentityParams ); + + /** + * Acquires codeseg information. + * @param aCodesegInfo The codeseg information which + is filled by the device driver + * @return TInt Returns KErrNone, if successful + otherwise one of the other system-wide error codes + */ + inline TInt GetCodesegInfo( TCodesegInfoBuf& aCodesegInfo ); + + /** + * Acquires library information. + * @param aLibraryInfo The library information which + is filled by the device driver + * @return TInt Returns KErrNone, if successful + otherwise one of the other system-wide error codes + */ + inline TInt GetLibraryInfo( TLibraryInfoBuf& aLibraryInfo ); + + /** + * Subscribes library event. + * @param aStatus The request status object for this request. + * @param aLibraryInfo The library information which + is filled by the device driver + * @return TInt Returns KErrNone, if successful + otherwise one of the other system-wide error codes + */ + inline void LibraryEvent( TRequestStatus& aStatus, + TLibraryEventInfo& aLibraryInfo ); + + /** + * Cancels subscribetion of the library event. + */ + inline void CancelLibraryEvent(); + + /** + * Acquires device driver current client count. + * @param aClientCount A reference to TInt which is + updated by the device driver. + * @return TInt Returns KErrNone, if successful + otherwise one of the other system-wide error codes + */ + inline TInt ClientCount( TClientCountBuf& aClientCount ); + + /** + * Acquires process main thread RAllocator + * @param aMainThreadParams The main thread information which + is filled by the device driver + * @return TInt Returns KErrNone, if successful + otherwise one of the other system-wide error codes + */ + inline TInt MainThreadAlloctor( TMainThreadParamsBuf& aMainThreadParams ); + + /** + * Acquires main thread stack address. + * @param aThreadStack Pointer to the TThreadParams object. + * @return TInt Returns KErrNone, if successful + otherwise one of the other system-wide error codes + */ + inline TInt ThreadStack( TThreadParamsBuf& aThreadStack ); + + /** + * Acquires information about process global handles. + * @param aProcessHandleInfo Pointer to the TProcessHandleInfo object. + * @return TInt Returns KErrNone, if successful + otherwise one of the other system-wide error codes + */ + inline TInt GetProcessHandleInfo( TProcessHandleInfoBuf& aProcessHandleInfo ); + + /** + * Acquires a process's current handle count. + * @param aProcessHandles Pointer to the TATProcessHandles object. + * @return TInt Returns KErrNone, if successful + otherwise one of the other system-wide error codes + */ + inline TInt GetCurrentHandleCount( TATProcessHandlesBuf& aProcessHandles ); + + /** + * Acquires memory model system uses. + * @param aMemoryModel pointer to the TATMemoryModelBuf object. + */ + inline TInt GetMemoryModel( TATMemoryModelBuf& aMemoryModel ); + +#endif // #ifndef __KERNEL_MODE__ + }; + +// INLINES +#include + +#endif // #ifndef __ANALYZETOOL_H__ + +// End of File diff -r d27dfa8884ad -r da2cedce4920 analyzetool/kerneleventhandler/inc/analyzetool.inl --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/kerneleventhandler/inc/analyzetool.inl Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,159 @@ +/* +* 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 inline methods of the class RAnalyzeTool. +* +*/ + + +#ifndef __ANALYZETOOL_INL +#define __ANALYZETOOL_INL + +#ifndef __KERNEL_MODE__ + +// ---------------------------------------------------------------------------- +// RAnalyzeTool::Open() +// Opens a handle to a analyze tool device driver +// ---------------------------------------------------------------------------- +// +inline TInt RAnalyzeTool::Open() + { + return DoCreate( KAnalyzeToolLddName, + KAnalyzeToolLddVersion(), + KNullUnit, + NULL, + NULL, + EOwnerProcess ); + } + +// ---------------------------------------------------------------------------- +// RAnalyzeTool::GetProcessInfo() +// Acquires process information. +// ---------------------------------------------------------------------------- +// +inline TInt RAnalyzeTool::GetProcessInfo( + TProcessIdentityParamsBuf& aProcessIdentityParams ) + { + return DoControl( EGetProcessInfo, &aProcessIdentityParams, NULL ); + } + +// ---------------------------------------------------------------------------- +// RAnalyzeTool::GetCodesegInfo() +// Acquires codeseg information. +// ---------------------------------------------------------------------------- +// +inline TInt RAnalyzeTool::GetCodesegInfo( TCodesegInfoBuf& aCodesegInfo ) + { + return DoControl( EGetCodesegInfo, &aCodesegInfo, NULL ); + } + +// ---------------------------------------------------------------------------- +// RAnalyzeTool::GetLibraryInfo() +// Symbian 2nd phase constructor can leave. +// ---------------------------------------------------------------------------- +// +inline TInt RAnalyzeTool::GetLibraryInfo( TLibraryInfoBuf& aLibraryinfo ) + { + return DoControl( EGetLibraryInfo, &aLibraryinfo, NULL ); + } + +// ---------------------------------------------------------------------------- +// RAnalyzeTool::LibraryEvent() +// Subscribes library event. +// ---------------------------------------------------------------------------- +// +inline void RAnalyzeTool::LibraryEvent( TRequestStatus& aStatus, + TLibraryEventInfo& aLibInfo ) + { + return DoRequest( ELibraryEvent, aStatus, (TAny*)&aLibInfo ); + } + +// ---------------------------------------------------------------------------- +// RAnalyzeTool::CancelLibraryEvent() +// Cancels subscribetion of the library event. +// ---------------------------------------------------------------------------- +// +inline void RAnalyzeTool::CancelLibraryEvent() + { + DoControl( ECancelLibraryEvent, NULL, NULL); + } + +// ---------------------------------------------------------------------------- +// RAnalyzeTool::ClientCount() +// Acquires the count of device driver current users +// ---------------------------------------------------------------------------- +// +inline TInt RAnalyzeTool::ClientCount( TClientCountBuf& aClientCount ) + { + return DoControl( ECurrentClientCount, &aClientCount, NULL ); + } + +// ---------------------------------------------------------------------------- +// RAnalyzeTool::MainThreadAlloctor() +// Acquires information about process main thread +// ---------------------------------------------------------------------------- +// +inline TInt RAnalyzeTool::MainThreadAlloctor( + TMainThreadParamsBuf& aMainThreadParams ) + { + return DoControl( EMainThreadAlloctor, &aMainThreadParams, NULL ); + } + +// ---------------------------------------------------------------------------- +// RAnalyzeTool::ThreadStack() +// Acquires main thread stack address. +// ---------------------------------------------------------------------------- +// +inline TInt RAnalyzeTool::ThreadStack( TThreadParamsBuf& aThreadStack ) + { + return DoControl( EThreadStack, &aThreadStack, NULL ); + } + +// ---------------------------------------------------------------------------- +// RAnalyzeTool::GetProcessHandleInfo() +// Acquires information about process handles +// ---------------------------------------------------------------------------- +// +inline TInt RAnalyzeTool::GetProcessHandleInfo( + TProcessHandleInfoBuf& aProcessHandleInfo ) + { + return DoControl( EGetProcessHandle, &aProcessHandleInfo, NULL ); + } + +// ----------------------------------------------------------------------------- +// DAnalyzeToolChannel::GetCurrentHandleCount() +// Acquires a process's current handle count +// ----------------------------------------------------------------------------- +// +inline TInt RAnalyzeTool::GetCurrentHandleCount( + TATProcessHandlesBuf& aProcessHandles ) + { + return DoControl( EGetCurrentHandles, &aProcessHandles, NULL ); + } + +// ----------------------------------------------------------------------------- +// DAnalyzeToolChannel::GetMemoryModel() +// Acquires memory model system uses. +// ----------------------------------------------------------------------------- +// +inline TInt RAnalyzeTool::GetMemoryModel( + TATMemoryModelBuf& aMemoryModel ) + { + return DoControl( EGetMemoryModel, &aMemoryModel, NULL ); + } + +#endif // #ifndef __KERNEL_MODE__ + +#endif // __ANALYZETOOL_INL + +// End of file diff -r d27dfa8884ad -r da2cedce4920 analyzetool/kerneleventhandler/inc/analyzetoolchannel.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/kerneleventhandler/inc/analyzetoolchannel.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,213 @@ +/* +* 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: Declaration of the class DAnalyzeToolChannel +* +*/ + + +#ifndef __ANALYZETOOLCHANNEL_H__ +#define __ANALYZETOOLCHANNEL_H__ + +// INCLUDES +#include +#include +#ifdef __WINSCW__ +#include +#endif // __WINSCW__ + +// FORWARD DECLARATIONS +class DAnalyzeToolEventHandler; + +// CLASS DECLARATION + +/** +* The implementation of the abstract base class for a logical channel. +*/ +class DAnalyzeToolChannel : public DLogicalChannel + { + public: + + /** + * C++ default constructor. + */ + DAnalyzeToolChannel(); + + /** + * Destructor. + */ + ~DAnalyzeToolChannel(); + + protected: // from DLogicalChannel + + /** + * Creates the logical channel. + * @param aUnit A unit of the device. + * @param anInfo A pointer to an explicit 8-bit descriptor containing + extra information for the physical device + * @param aVer The required version of the logical device + * @return TInt Returns KErrNone, if successful + otherwise one of the other system-wide error codes + */ + virtual TInt DoCreate( TInt aUnit, + const TDesC8* anInfo, + const TVersion &aVer ); + + /** + * Handles a client request. + * @param aFunction The requested function. + * @param a1 A 32-bit value passed to the kernel-side. Its meaning + depends on the device driver requirements + * @param a2 A 32-bit value passed to the kernel-side. Its meaning + depends on the device driver requirements + * @param aMessage Reference to received thread message. + * @return TInt Returns KErrNone, if successful + otherwise one of the other system-wide error codes + */ + virtual TInt DoControl( TInt aFunction, TAny* a1, TAny* a2, TThreadMessage& aMessage ); + + /** + * Processes a message for this logical channel. + * This function is called in the context of a DFC thread. + * @param aMsg The message to process. + */ + virtual void HandleMsg( TMessageBase* aMsg ); + + /** + * Handles a client asynchronous request. + * @param aFunction The requested function. + * @param aStatus Pointer to client TRequestStatus. + * @param a1 A 32-bit value passed to the kernel-side. Its meaning + depends on the device driver requirements + * @param a2 A 32-bit value passed to the kernel-side. Its meaning + depends on the device driver requirements + * @param aMessage Reference to received thread message. + * @return TInt Returns KErrNone, if successful + otherwise one of the other system-wide error codes + */ + virtual TInt DoRequest( TInt aFunction, + TRequestStatus* aStatus, + TAny* a1, + TAny* a2, + TThreadMessage& aMessage ); + + /** + * Cancels outstanding asynchronous request. + */ + virtual void DoCancel(); + + private: + + /** + * Acquires current process information + * @param aProcessInfo Pointer to the TProcessIdentityParams object. + * @return TInt Returns KErrNone, if successful + otherwise one of the other system-wide error codes + */ + TInt GetProcessInfo( TAny* aProcessInfo, TThreadMessage& aMessage ); + + /** + * Acquires codeseg information. + * @param aCodesegInfo Pointer to the TCodesegInfo object. + * @return TInt Returns KErrNone, if successful + otherwise one of the other system-wide error codes + */ + TInt GetCodesegInfo( TAny* aCodesegInfo, TThreadMessage& aMessage ); + + /** + * Acquires library information. + * @param aLibraryInfo Pointer to the TLibraryInfo object. + * @return TInt Returns KErrNone, if successful + otherwise one of the other system-wide error codes + */ + TInt GetLibraryInfo( TAny* aLibraryInfo, TThreadMessage& aMessage ); + + /** + * Acquires information about process main thread RAllocator. + * @param aMainThreadParams Pointer to the TMainThreadParams object. + * @return TInt Returns KErrNone, if successful + otherwise one of the other system-wide error codes + */ + TInt MainThreadAllocator( TAny* aMainThreadParams, + TThreadMessage& aMessage ); + + /** + * Acquires main thread stack address. + * @param aThreadStack Pointer to the TThreadParams object. + * @return TInt Returns KErrNone, if successful + otherwise one of the other system-wide error codes + */ + TInt ThreadStack( TAny* aThreadStack, + TThreadMessage& aMessage ); + + /** + * Acquires information about process global handles. + * @param aProcessHandleInfo Pointer to the TProcessHandleInfo object. + * @return TInt Returns KErrNone, if successful + otherwise one of the other system-wide error codes + */ + TInt GetProcessHandleInfo( TAny* aProcessHandleInfo, + TThreadMessage& aMessage ); + + /** + * Acquires a process's current handle count. + * @param aProcessHandles Pointer to the TATProcessHandles object. + * @return TInt Returns KErrNone, if successful + otherwise one of the other system-wide error codes + */ + TInt GetCurrentHandleCount( TAny* aProcessHandles, + TThreadMessage& aMessage ); + + /** + * Acquires the count of current device driver users. + * @param aClientCount A reference to TInt variable + * @return TInt Returns KErrNone, if successful + * otherwise one of the other system-wide error codes + */ + TInt ClientCount( TAny* aClientCount, + TThreadMessage& aMessage ); + + /** + * Acquires memory model system uses. + * @return TInt Returns KErrNone, if successful + * otherwise one of the other system-wide error codes + */ + TInt GetMemoryModel( TAny* aMemoryModel, + TThreadMessage& aMessage ); + + #ifdef __WINSCW__ + /** + * Gets module dependencies + * @param aModule Module handle + */ + void GetModuleDependencies( HMODULE aModule ); + #endif // __WINSCW__ + + private: //Member variables + + /* Handler which receives kernel events */ + DAnalyzeToolEventHandler* iEventHandler; + + #ifdef __WINSCW__ + /* Code segment array */ + RArray iCodeSeg; + #endif // __WINSCW__ + + /* A DFC queue for communication */ + TDynamicDfcQue* iOwnDfcQ; + + }; + +#endif // #ifndef __ANALYZETOOLCHANNEL_H__ + +// End of File diff -r d27dfa8884ad -r da2cedce4920 analyzetool/kerneleventhandler/inc/analyzetooldevice.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/kerneleventhandler/inc/analyzetooldevice.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,68 @@ +/* +* 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: Declaration of the class DAnalyzeToolDevice. +* +*/ + + +#ifndef __ANALYZETOOLEVICE_H__ +#define __ANALYZETOOLEVICE_H__ + +// INCLUDES +#include +#include + +// CLASS DECLARATION + +/** +* The implementation of the abstract base class for an LDD factory object. +*/ + +class DAnalyzeToolDevice : public DLogicalDevice + { + public: + + /** + * C++ default constructor. + */ + DAnalyzeToolDevice(); + + public: // from DLogicalDevice + + /** + * Second stage constructor. + @return KErrNone or standard error code. + */ + virtual TInt Install(); + + /** + * Gets the driver's capabilities. + @param aDes A user-side descriptor into which capabilities + information is to be written. + */ + virtual void GetCaps( TDes8& aDes ) const; + + /** + * Called by the kernel's device driver framework to + * create a Logical Channel. + @param aChannel Set to point to the created Logical Channel + @return KErrNone or standard error code. + */ + virtual TInt Create( DLogicalChannelBase*& aChannel ); + }; + + +#endif // __ANALYZETOOLEVICE_H__ + +// End of File diff -r d27dfa8884ad -r da2cedce4920 analyzetool/kerneleventhandler/inc/analyzetooleventhandler.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/kerneleventhandler/inc/analyzetooleventhandler.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,168 @@ +/* +* 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: Declaration of the class DAnalyzeToolEventHandler. +* +*/ + + +#ifndef __ANALYZETOOLEVENTHANDLER_H__ +#define __ANALYZETOOLEVENTHANDLER_H__ + +// INCLUDES +#include +#include "atlog.h" +#include + +// CLASS DECLARATION + +/** +* Callback class for kernel events +*/ + +class DAnalyzeToolEventHandler : public DKernelEventHandler + { + public: + + /** + * C++ default constructor. + */ + inline DAnalyzeToolEventHandler( TDfcQue* aDfcQ ); + + /** + * Destructor. + */ + ~DAnalyzeToolEventHandler(); + + /** + * Second stage constructor. + * @param aDevice A pointer to device where the event handler belongs. + * @param aProcessId Owner process id. + * @return TInt Returns KErrNone, if successful + otherwise one of the other system-wide error codes + */ + TInt Create( DLogicalDevice* aDevice, const TUint aProcessId ); + + /** + * Subscribes library event. + * @param aStatus The request status object for this request. + * @param aLibraryInfo The library information which + is filled by the device driver + * @param aMessage Reference to received thread message. + * @return TInt Returns KErrNone, if successful + otherwise one of the other system-wide error codes + */ + void InformLibraryEvent( TRequestStatus* aStatus, + TAny* aLibraryInfo, + TThreadMessage& aMessage ); + + /** + * Cancels subscribetion of the library event. + */ + void CancelInformLibraryEvent(); + + /** + * Static function for DFC events. + * @param aPtr Pointer to DAnalyzeToolEventHandler object. + */ + static void EventDfc( TAny* aPtr ); + + private: + + /** + * Pointer to callback function called when an event occurs. + * @param aEvent Designates what event is dispatched. + * @param a1 Event-specific paramenter. + * @param a2 Event-specific paramenter. + * @param aThis A pointer to the event handler + * @return TUint Bitmask returned by callback function. + */ + static TUint EventHandler( TKernelEvent aEvent, + TAny* a1, + TAny* a2, + TAny* aThis ); + + private: + + /** + * Handles the EEventAddLibrary and EEventRemoveLibrary events + * @param aLib* A pointer to added/removed library. + * @param aThread* A pointer to thread where the libary is. + * @param aInfo* A reference class to be written to the client + */ + void HandleLibraryEvent( DLibrary* aLib, + DThread* aThread, + TLibraryEventInfo& aInfo ); + + /** + * Handles the EEventKillThread events + * @param aThread* A pointer to the thread being terminated. + * @param aInfo* A reference class + */ + void HandleKillThreadEvent( DThread* aThread, + TLibraryEventInfo& aInfo ); + + /** + * Informs client about the occured event + */ + void DoEventComplete(); + + private: + + /* Mutex for serializing access to event handler */ + DMutex* iHandlerMutex; + + /* Mutex fof serializing access to event handler variables */ + DMutex* iDataMutex; + + /* If the client is a RAM-loaded LDD (or PDD), it is possible for the DLL to + be unloaded while the handler is still in use. This would result in an + exception. To avoid this, the handler must open a reference to the + DLogicalDevice (or DPhysicalDevice) and close it in its d'tor. */ + DLogicalDevice* iDevice; + + /* Owner process ID */ + TUint iProcessId; + + /* Event array */ + RArray iEventArray; + + /* Pointer to client's TRequestStatus */ + TRequestStatus* iClientRequestStatus; + + /* Pointer to client's thread */ + DThread* iClientThread; + + /* Pointer to client's TLibraryEventInfo */ + TAny* iClientInfo; + + /* DFC for informing events to the client */ + TDfc iEventDfc; + }; + +// ---------------------------------------------------------------------------- +// DAnalyzeToolEventHandler::DAnalyzeToolEventHandler() +// C++ default constructor. +// ---------------------------------------------------------------------------- +// +inline DAnalyzeToolEventHandler::DAnalyzeToolEventHandler( TDfcQue* aDfcQ ) : + DKernelEventHandler( EventHandler, this ), + iEventDfc( EventDfc, this, 1 ) + { + LOGSTR1( "ATDD DAnalyzeToolEventHandler::DAnalyzeToolEventHandler()" ); + iEventDfc.SetDfcQ( aDfcQ ); + } + +#endif // __ANALYZETOOLEVENTHANDLER_H__ + +// End of File diff -r d27dfa8884ad -r da2cedce4920 analyzetool/kerneleventhandler/inc/analyzetooltraceconstants.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/kerneleventhandler/inc/analyzetooltraceconstants.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,171 @@ +/* +* 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: Common declarations/definitions for Analyze Tool. +* +*/ + + + +#ifndef __ANALYZETOOLTRACECONSTANTS_H__ +#define __ANALYZETOOLTRACECONSTANTS_H__ + +#include + +// Trace version information. +const TUint KATTraceVersion = 0x2; + +// The default logging mode +const TATLogOption KDefaultLoggingMode = EATLogToTrace; + +// When needed, update the storage data file's version number directly inside +// the _LIT8 macro. Note, if you change this string, also remember to update +// the constant "KVersionStringLength" below. + +_LIT8( KDataFileVersion, "DATA_FILE_VERSION 11\r\n" ); +_LIT8( KProcessStart, "PROCESS_START %S %x " ); +_LIT16( KProcessStart16, "PROCESS_START %S %x " ); +_LIT8( KDllLoad, "DLL_LOAD %S %Lx %x %x\r\n" ); +_LIT16( KDllLoad16, "DLL_LOAD %S %Lx %x %x\r\n" ); +_LIT8( KDllUnload, "DLL_UNLOAD %S %Lx %x %x\r\n" ); +_LIT16( KDllUnload16, "DLL_UNLOAD %S %Lx %x %x\r\n" ); +_LIT8( KProcessEnd, "PROCESS_END %x " ); +_LIT16( KProcessEnd16, "PROCESS_END %x " ); +_LIT8( KProcessEndAbnormal, "PROCESS_END %x ABNORMAL " ); +_LIT8( KMemoryLeak, "MEM_LEAK " ); // Remember to update value of KMemoryLeak when changing this. +_LIT8( KHandleLeak, "HANDLE_LEAK %S %x\r\n" ); +_LIT16( KHandleLeak16, "HANDLE_LEAK %S %x\r\n" ); +_LIT8( KErrorOccured, "ERROR_OCCURED %d " ); +_LIT8( KLoggingCancelled, "LOGGING_CANCELLED %x\r\n" ); +_LIT8( KNewLine, "\r\n" ); +_LIT8( KHexaNumber, " %x" ); +_LIT8( KSpace, " " ); +_LIT8( KUdeb, "UDEB" ); +_LIT8( KUrel, "UREL" ); + +// Constants for logging through debug channel +_LIT( KTraceMessage, "PCSS %x %S" ); +_LIT( KMemoryAllocHeader, "ALLOCH " ); +_LIT( KMemoryAllocFragment, "ALLOCF " ); +_LIT( KMemoryFreedHeader, "FREEH " ); +_LIT( KMemoryFreedFragment, "FREEF " ); +_LIT( KSpaceTrace, " " ); +_LIT( KNewLineTrace, "\r\n" ); +_LIT( KHexaNumberTrace, " %x" ); +_LIT( KProcessEndTrace, "PROCESS_END %x " ); +_LIT( KProcessEndAbnormalTrace, "PROCESS_END %x ABNORMAL " ); +_LIT( KErrorOccuredTrace, "ERROR_OCCURED %d " ); +_LIT( KSubtestStart, "TEST_START " ); +_LIT( KSubtestEnd, "TEST_END " ); +_LIT8( KEmpty, "" ); +_LIT( KOpenSquareBracket, "[" ); +_LIT( KCloseSquareBracket, "]" ); +_LIT( KUnderLine, "_" ); +// File name format +_LIT( KFormat, "%S%S%02d%S");// pad char="0", field width=2 + +// A string for setting time January 1st, 1970 AD nominal Gregorian +_LIT( KJanuaryFirst1970, "19700000:000000.000000" ); + +// Module name when it cannot be defined +_LIT8( KUnknownModule, "Unknown" ); +_LIT16( KUnknownModule16, "Unknown" ); + +// Constant time variable used to calculate timestamps for pc side. +const TInt64 KMicroSecondsAt1970 = 62168256000000000; + +// The length of the string KDataFileVersion +const TInt KVersionStringLength = 22; + +// The length of the string KMemoryLeak +const TInt KMemleakLength = 9; + +// The maximum length of one word (32 bits) represented in the hexadecimal text format +// without "0x" prefix +const TInt KHexa32Length = 8; + +// The maximum length of one word (32 bits) represented in the decimal text format +const TInt KDec32Length = 10; + +// The maximum length of a TInt64 represented in the hexadecimal text format without +// "0x" prefix +const TInt KHexa64Length = 16; + +// The length of one space character in text +const TInt KSpaceLength = 1; + +// The length of the combination of carriage return and new line characters. +const TInt KNewlineLength = 2; + +// The maximum length of the "PROCESS_START..." buffer. The first number is length of +// the line tag and one space character (see the descriptor constants above). +const TInt KProcessStartBufLength = 16 + KMaxProcessName + KSpaceLength + KHexa32Length + + KSpaceLength + KHexa64Length + KHexa32Length + KNewlineLength; + +// The maximum length of the "DLL_LOAD..." buffer. The first number is length of +// the line tag and one space character (see the descriptor constants above). +const TInt KDllLoadBufLength = 9 + KMaxLibraryName + KSpaceLength + KHexa64Length + KSpaceLength + + KHexa32Length + KSpaceLength + KHexa32Length + KNewlineLength; + +// The maximum length of the "DLL_UNLOAD..." buffer. The first number is length of +// the line tag and one space character (see the descriptor constants above). +const TInt KDllUnloadBufLength = 11 + KMaxLibraryName + KHexa64Length + KSpaceLength + KSpaceLength + + KHexa32Length + KSpaceLength + KHexa32Length + KNewlineLength; + +// The maximum length of the "PROCESS_END..." buffer. The first number is length of +// the line tag and one space character (see the descriptor constants above). +const TInt KProcessEndBufLength = 12 + KHexa32Length + KSpaceLength + + KHexa64Length + KNewlineLength; + +// The maximum length of the "ERROR_OCCURED..." buffer. The first number is length of +// the line tag and one space character (see the descriptor constants above). +const TInt KErrOccuredBufLength = 14 + KDec32Length + KSpaceLength + + KHexa64Length + KNewlineLength; + +// The maximum length of the "ALLOCH / ALLOCF..." buffer. +const TInt KMemAllocBufLength = 255; + +// The maximum length of the "FREE..." buffer. +const TInt KMemFreedBufLength = 255; + +// The maximum length of the "HANDLE_LEAK..." buffer. The first number is length of +// the line tag and one space character (see the descriptor constants above). +const TInt KHandleLeakBufLength = 12 + KMaxLibraryName + KSpaceLength + + KHexa32Length + KNewlineLength; + +// The maximum length of the "TEST_START..." buffer. The first number is length of +// the line tag and one space character (see the descriptor constants above). +const TInt KTestStartBufLength = 11 + KHexa64Length + KSpaceLength + + KATMaxSubtestIdLength + KSpaceLength + KHexa64Length + KNewlineLength; + +// The maximum length of the "TEST_END..." buffer. The first number is length of +// the line tag and one space character (see the descriptor constants above). +const TInt KTestEndBufLength = 9 + KHexa64Length + KSpaceLength + + KATMaxSubtestIdLength + KSpaceLength + KHexa64Length + KNewlineLength; + +// The maximun length of the "LOGGING_CANCELLED..." buffer. The first number is the +// length of the line tag and one space character (see the descriptor constants above). +const TInt KCancelBufLength = 18 + KHexa64Length + KNewlineLength; + +// The maximun length of the "PROCESS_END %x ABNORMAL..." buffer. The first number is length of +// the line tag and one space character (see the descriptor constants above). +const TInt KEndAbnormalBufLength = 22 + KHexa32Length + KHexa64Length + + KSpaceLength + KNewlineLength; + +// The maximun length of the file name extension buffer. +const TInt KExtensionLength = 50; + +// The maximun length of the process UID3 buffer. +const TInt KProcessUidLength = 20; + +#endif // __ANALYZETOOLTRACECONSTANTS_H__ diff -r d27dfa8884ad -r da2cedce4920 analyzetool/kerneleventhandler/inc/atcommon.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/kerneleventhandler/inc/atcommon.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,108 @@ +/* +* 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: Common declarations/definitions for Analyze Tool. +* +*/ + + +#ifndef ATCOMMON_H_ +#define ATCOMMON_H_ + +// CONSTANTS +const TInt KATMaxCallstackLength = 256; +const TInt KATMaxFreeCallstackLength = 256; +const TInt KATMaxSubtestIdLength = 256; + +// The following constants only limit the configuration UI. +// The bigger the number is, the more space will be allocated run-time +// by the client. So, change with care. +const TInt KATMaxProcesses = 20; +const TInt KATMaxDlls = 30; + +// Constants defining call stack address range in multiple memory model. +const TInt32 KATMultipleMemoryModelLowLimit = 0x70000000; +const TInt32 KATMultipleMemoryModelHighLimit = 0x90000000; + + +// CLASS DECLARATIONS + +/** +* A class for storing process information +*/ +class TATProcessInfo + { + public: + + /** The ID of the process. */ + TUint iProcessId; + + /** The name of the process. */ + TBuf8 iProcessName; + + /** The starting time of the process. */ + TInt64 iStartTime; + }; + + +// ENUMERATIONS + +/** +* Enumeration for different logging modes of Analyze Tool +*/ +enum TATLogOption + { + /** Using the default. */ + EATUseDefault = 0, + + /** Logging to a file in S60. */ + EATLogToFile, + + /** Logging to debug channel. */ + EATLogToTrace, + + /** Logging to debug channel bypassing storage server. */ + EATLogToTraceFast, + + /** Logging switched off. */ + EATLoggingOff + }; + +/** +* Class which supports interfacing with AnalyzeTool exported +* functions. Mainly meant for STIF integration. +*/ +class AnalyzeToolInterface + { + public: + + /** + * This function starts subtest with a given name. + * @param aSubtestId The name identifying this particular sub test. The length + * of this descriptor must not be greater than KATMaxSubtestIdLength, or + * otherwise the method raises a STSEClient: 2 panic. + */ + IMPORT_C static void StartSubTest( const TDesC8& aSubtestId ); + + /** + * This function stops a subtest with a given name. + * @param aSubtestId The name identifying this particular sub test. The length + * of this descriptor must not be greater than KATMaxSubtestIdLength, or + * otherwise the method raises a STSEClient: 2 panic. + */ + IMPORT_C static void StopSubTest( const TDesC8& aSubtestId ); + + }; + + +#endif /*ATCOMMON_H_*/ diff -r d27dfa8884ad -r da2cedce4920 analyzetool/kerneleventhandler/sis/analyzetooldevicedriver.pkg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/kerneleventhandler/sis/analyzetooldevicedriver.pkg Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,33 @@ +; +; 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: +; + +;Language - standard language definitions +&EN + +; standard SIS file header +#{"AnalyzeToolDeviceDriver"},(0xEDF5A8A1),1,8,1 + +;Localised Vendor name +%{"Vendor-EN"} + +;Unique Vendor name +:"Vendor" + +;Supports Series 60 v 3.0 +[0x101F7961], 0, 0, 0, {"Series60ProductID"} + +; 1 File to install +"\epoc32\release\armv5\urel\atoolkerneleventhandler.ldd"-"!:\sys\bin\atoolkerneleventhandler.ldd" diff -r d27dfa8884ad -r da2cedce4920 analyzetool/kerneleventhandler/src/analyzetoolchannel.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/kerneleventhandler/src/analyzetoolchannel.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,1019 @@ +/* +* 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 DAnalyzeToolChannel. +* +*/ + + +// INCLUDE FILES +#include "analyzetoolchannel.h" +#include "analyzetooldevice.h" +#include "analyzetooleventhandler.h" + +#include +#ifdef __WINSCW__ +#include +#endif // __WINSCW__ + +#include "atlog.h" + +// ================= MEMBER FUNCTIONS ========================================= + +// ----------------------------------------------------------------------------- +// DAnalyzeToolChannel::DoCreate() +// Creates the logical channel. +// ----------------------------------------------------------------------------- +// +TInt DAnalyzeToolChannel::DoCreate( TInt /*aUnit*/, + const TDesC8* /*aInfo*/, const TVersion &aVer ) + { + LOGSTR1( "ATDD DAnalyzeToolChannel::DoCreate()" ); + + // Check client version. + if ( !Kern::QueryVersionSupported( KAnalyzeToolLddVersion(), aVer ) ) + { + return KErrNotSupported; + } + + TInt error = Kern::DynamicDfcQCreate( iOwnDfcQ, + KAnalyzeToolThreadPriority, + KAnalyzeToolThreadName ); + + if ( KErrNone != error ) + { + return error; + } + + SetDfcQ( iOwnDfcQ ); + + iMsgQ.Receive(); + + // Create the event handler + iEventHandler = new DAnalyzeToolEventHandler( iOwnDfcQ ); + + // Check that everything is OK + if ( !iEventHandler ) + { + return KErrNoMemory; + } + + // 2nd stage constructor for event handler + return iEventHandler->Create( iDevice, Kern::CurrentProcess().iId ); + } + +// ----------------------------------------------------------------------------- +// DAnalyzeToolChannel::DAnalyzeToolChannel() +// Constructor. +// ----------------------------------------------------------------------------- +// +DAnalyzeToolChannel::DAnalyzeToolChannel() + { + LOGSTR1( "ATDD DAnalyzeToolChannel::DAnalyzeToolChannel()" ); + } + +// ----------------------------------------------------------------------------- +// DAnalyzeToolChannel::~DAnalyzeToolChannel() +// Destructor. +// ----------------------------------------------------------------------------- +// +DAnalyzeToolChannel::~DAnalyzeToolChannel() + { + LOGSTR1( "ATDD DAnalyzeToolChannel::~DAnalyzeToolChannel()" ); + + if ( iEventHandler ) + { + // Cancel all processing that we may be doing + DoCancel(); + + // Client code should use Close() instead the operator delete + // to destroy the event handler. + TInt error( iEventHandler->Close() ); + if ( KErrNone != error ) + { + LOGSTR2( "ATDD iEventHandler->Close(%d)", error ); + } + } + #ifdef __WINSCW__ + iCodeSeg.Close(); + #endif // __WINSCW__ + + // Destroy the queqe + if ( iOwnDfcQ ) + { + iOwnDfcQ->Destroy(); + } + } + +// ----------------------------------------------------------------------------- +// DAnalyzeToolChannel::DoControl() +// Handles a client request. +// ----------------------------------------------------------------------------- +// +TInt DAnalyzeToolChannel::DoControl( TInt aFunction, + TAny* a1, + TAny* /*a2*/, + TThreadMessage& aMessage ) + { + LOGSTR1( "ATDD DAnalyzeToolChannel::Request()" ); + + TInt ret( KErrNone ); + + // Check the requested function + switch (aFunction) + { + case RAnalyzeTool::EGetProcessInfo: + ret = GetProcessInfo( a1, aMessage ); + break; + + case RAnalyzeTool::EGetCodesegInfo: + ret = GetCodesegInfo( a1, aMessage ); + break; + + case RAnalyzeTool::EGetLibraryInfo: + ret = GetLibraryInfo( a1, aMessage ); + break; + + case RAnalyzeTool::ECancelLibraryEvent: + iEventHandler->CancelInformLibraryEvent(); + break; + + case RAnalyzeTool::ECurrentClientCount: + ret = ClientCount( a1, aMessage ); + break; + + case RAnalyzeTool::EMainThreadAlloctor: + ret = MainThreadAllocator( a1, aMessage ); + break; + + case RAnalyzeTool::EThreadStack: + ret = ThreadStack( a1, aMessage ); + break; + + case RAnalyzeTool::EGetProcessHandle: + ret = GetProcessHandleInfo( a1, aMessage ); + break; + + case RAnalyzeTool::EGetCurrentHandles: + ret = GetCurrentHandleCount( a1, aMessage ); + break; + case RAnalyzeTool::EGetMemoryModel: + ret = GetMemoryModel( a1, aMessage ); + break; + + // Unsupported function. Panic + default: + Kern::PanicCurrentThread( KClientPanic, EPanicUnsupportedRequest ); + break; + } + + return ret; + } + +// ----------------------------------------------------------------------------- +// DAnalyzeToolChannel::DoRequest() +// Handles a client asynchronous request. +// ----------------------------------------------------------------------------- +// +TInt DAnalyzeToolChannel::DoRequest( TInt aFunction, + TRequestStatus* aStatus, + TAny* a1, + TAny* /*a2*/, + TThreadMessage& aMessage ) + { + LOGSTR1( "ATDD DAnalyzeToolChannel::DoRequest()" ); + + // Check the requested function + switch (aFunction) + { + case RAnalyzeTool::ELibraryEvent: + iEventHandler->InformLibraryEvent( aStatus, a1, aMessage ); + break; + + // Unsupported function. Panic + default: + aMessage.PanicClient( KClientPanic, EPanicUnsupportedRequest ); + break; + } + + return KErrNone; + } + +// ----------------------------------------------------------------------------- +// DAnalyzeToolChannel::DoCancel() +// Cancels outstanding asynchronous request. +// ----------------------------------------------------------------------------- +// +void DAnalyzeToolChannel::DoCancel() + { + LOGSTR1( "ATDD DAnalyzeToolChannel::DoCancel()" ); + + iEventHandler->CancelInformLibraryEvent(); + } + +// ----------------------------------------------------------------------------- +// DAnalyzeToolChannel::HandleMsg() +// Processes a message for this logical channel. +// ----------------------------------------------------------------------------- +// +void DAnalyzeToolChannel::HandleMsg(TMessageBase* aMsg) + { + LOGSTR1( "ATDD DAnalyzeToolChannel::HandleMsg()" ); + + TThreadMessage& message = *(TThreadMessage*)aMsg; + + // Get message type + TInt id = message.iValue; + + // Decode the message type and dispatch it to the relevent handler function... + if ( id == (TInt) ECloseMsg ) + { + // Channel Close + DoCancel(); + message.Complete( KErrNone, EFalse ); + } + else if ( id == KMaxTInt ) + { + // DoCancel + DoCancel(); + message.Complete( KErrNone, ETrue ); + } + else if ( id < 0 ) + { + // DoRequest + TRequestStatus* status = (TRequestStatus*) message.Ptr0(); + TInt error = DoRequest( ~id, status, message.Ptr1(), message.Ptr2(), message ); + if ( KErrNone != error ) + { + Kern::RequestComplete( message.Client(), status, error); + } + message.Complete(KErrNone, ETrue ); + } + else + { + // DoControl + TInt ret = DoControl( id, message.Ptr0(), message.Ptr1(), message ); + message.Complete( ret, ETrue ); + } + } + +// ----------------------------------------------------------------------------- +// DAnalyzeToolChannel::GetProcessInfo() +// Acquires current process information +// ----------------------------------------------------------------------------- +// +TInt DAnalyzeToolChannel::GetProcessInfo( TAny* aProcessInfo, + TThreadMessage& aMessage ) + { + LOGSTR1( "ATDD DAnalyzeToolChannel::GetProcessInfo()" ); + + // Variable for reading parameters from user side + TProcessIdentityParamsBuf params; + + // Reads a descriptor from a thread's process. + TInt error = Kern::ThreadDesRead( aMessage.Client(), aProcessInfo, params, 0 ); + + if ( KErrNone != error ) + { + LOGSTR2( "ATDD ThreadDesRead error %d", error ); + return error; + } + + // Gets the current process + Kern::Containers()[ EProcess ]->Wait(); + DProcess& process = *Kern::ProcessFromId( params().iProcessId ); + Kern::Containers()[ EProcess ]->Signal(); + + if ( NULL == &process ) + { + return KErrNotFound; + } + + // Temporary variable for collecting information from the process + TProcessIdentityParamsBuf info; + + // Collect needed information from the process + process.AppendName( info().iProcessName );//lint !e64 !e1514 + + // Gets the current thread + Kern::Containers()[ EThread ]->Wait(); + DThread& thread = *Kern::ThreadFromId( params().iThreadId ); + Kern::Containers()[ EThread ]->Signal(); + + if ( NULL == &thread ) + { + return KErrNotFound; + } + + // Stack address of the main thread + info().iStackAddress = thread.iUserStackRunAddress; + info().iStackSize = thread.iUserStackSize; + + // Enters thread critical section and acquires code segment mutex. + Kern::AccessCode(); + + // Collect needed information from the process + info().iDynamicCount = process.iDynamicCode.Count(); + + // Temporary queue for acquiring the count of codesegments + SDblQue queue; + + // Acquire the count of codesegments + TInt codesegCount = process.TraverseCodeSegs( &queue, + NULL, + DCodeSeg::EMarkDebug, + DProcess::ETraverseFlagAdd ); + + #ifndef __WINSCW__ + info().iCodesegCount = codesegCount; + #else + // Reset codesegment array + iCodeSeg.Reset(); + + if ( codesegCount > 0 ) + { + SDblQueLink* link = queue.iA.iNext; + TCodesegInfo codeinfo; + // Iterate through codesegments + for ( TInt i = 0; i < codesegCount; ++i, link = link->iNext ) + { + DWin32CodeSeg* codeseg = + (DWin32CodeSeg*)_LOFF( link, DCodeSeg, iTempLink ); + + // Aqcuire codeseg information + codeinfo.iFileEntryPoint = codeseg->iFileEntryPoint; + codeinfo.iSize = codeseg->iSize; + codeinfo.iFullName.Copy( codeseg->iRootName ); + codeinfo.iRunAddress = codeseg->iRunAddress; + iCodeSeg.Append( codeinfo ); + } + } + + // Add dependency codesegments + DWin32CodeSeg* pcodeSeg = (DWin32CodeSeg*)process.iCodeSeg; + + // Get dependency codesegments + GetModuleDependencies( pcodeSeg->iModuleHandle ); + + // Set codesegment count + info().iCodesegCount = iCodeSeg.Count(); + #endif + + // Removes all code segments from a queue and clear specified mark(s) + DCodeSeg::EmptyQueue( queue, DCodeSeg::EMarkDebug ); + + // Exits thread critical section and releases code segment mutex. + Kern::EndAccessCode(); + + // Writes a descriptor to a thread's process. + error = Kern::ThreadDesWrite( aMessage.Client(), aProcessInfo, info, 0 ); + + if ( KErrNone != error ) + { + LOGSTR2( "ATDD ThreadDesWrite error %d", error ); + return error; + } + + return KErrNone; + } + +// ----------------------------------------------------------------------------- +// DAnalyzeToolChannel::GetCodesegInfo() +// Acquires codeseg information. +// ----------------------------------------------------------------------------- +// +TInt DAnalyzeToolChannel::GetCodesegInfo( TAny* aCodesegInfo, + TThreadMessage& aMessage ) + { + LOGSTR1( "ATDD DAnalyzeToolChannel::GetCodesegInfo()" ); + + // Temporary variable for collecting information from the codeseg + TCodesegInfoBuf params; + + TInt error( KErrArgument ); + + // Reads a descriptor from a thread's process. + error = Kern::ThreadDesRead( aMessage.Client(), aCodesegInfo, params, 0 ); + + if ( KErrNone != error ) + { + LOGSTR2( "ATDD ThreadDesRead error %d", error ); + return error; + } + + if ( params().iIndex < 0 ) + { + return KErrArgument; + } + + // Gets the current process + Kern::Containers()[ EProcess ]->Wait(); + DProcess& process = *Kern::ProcessFromId( params().iProcessId ); + Kern::Containers()[ EProcess ]->Signal(); + + if ( NULL == &process ) + { + return KErrNotFound; + } + + // Temporary variable for collecting information + TCodesegInfoBuf output; + + // Enters thread critical section and acquires code segment mutex. + Kern::AccessCode(); + + #ifndef __WINSCW__ + // Temporary queue for acquiring the codesegments + SDblQue queue; + + // Acquire the codesegments + TInt actcount = process.TraverseCodeSegs( &queue, + NULL, + DCodeSeg::EMarkDebug, + DProcess::ETraverseFlagAdd ); + if ( actcount >= params().iIndex ) + { + LOGSTR1( "ATDD DAnalyzeToolChannel::GetCodesegInfo() - actcount >= params.iIndex" ); + SDblQueLink* link = queue.iA.iNext; + + // Iterate through codesegments + for (TInt i = 0; i < actcount; ++i, link = link->iNext) + { + DCodeSeg* codeseg = _LOFF( link, DCodeSeg, iTempLink ); + + // Is the codesegments which information client wants + if ( i == params().iIndex ) + { + // Aqcuire codeseg information + output().iFileEntryPoint = codeseg->iFileEntryPoint; + output().iSize = codeseg->iSize; + output().iFullName.Copy( codeseg->iRootName ); + output().iRunAddress = codeseg->iRunAddress; + error = codeseg->GetMemoryInfo( output().iMemoryInfo, &process ); + + if ( KErrNone == error ) + { + // Writes a descriptor to a thread's process. + error = Kern::ThreadDesWrite( aMessage.Client(), + aCodesegInfo, + output, + 0 ); + if ( KErrNone != error ) + { + LOGSTR2( "ATDD ThreadDesWrite error %d", error ); + } + } + break; + } + } + } + // Removes all code segments from a queue and clear specified mark(s). + DCodeSeg::EmptyQueue( queue, DCodeSeg::EMarkDebug ); + + // Exits thread critical section and releases code segment mutex. + Kern::EndAccessCode(); + + return error; + #else // WINSCW + + if ( iCodeSeg.Count() > params().iIndex ) + { + // Aqcuire codeseg information + output().iSize = iCodeSeg[params().iIndex].iSize; + output().iFullName.Copy( iCodeSeg[params().iIndex].iFullName ); + output().iRunAddress = iCodeSeg[params().iIndex].iRunAddress; + + // Writes a descriptor to a thread's process. + error = Kern::ThreadDesWrite( aMessage.Client(), aCodesegInfo, output, 0 ); + + if ( KErrNone != error ) + { + LOGSTR2( "ATDD ThreadDesWrite error %d", error ); + } + } + + // Exits thread critical section and releases code segment mutex. + Kern::EndAccessCode(); + + return error; + #endif + } + +// ----------------------------------------------------------------------------- +// DAnalyzeToolChannel::GetLibraryInfo() +// Acquires library information. +// ----------------------------------------------------------------------------- +// +TInt DAnalyzeToolChannel::GetLibraryInfo( TAny* aLibraryInfo, + TThreadMessage& aMessage ) + { + LOGSTR1( "ATDD DAnalyzeToolChannel::GetLibraryInfo()" ); + + // Temporary variable for reading informationfrom the user side + TLibraryInfoBuf params; + + // Reads a descriptor from a thread's process. + TInt error = Kern::ThreadDesRead( aMessage.Client(), aLibraryInfo, params, 0 ); + + if ( KErrNone != error ) + { + LOGSTR2( "ATDD ThreadDesRead error %d", error ); + return error; + } + + if ( params().iIndex < 0 ) + { + return KErrArgument; + } + + // Gets the current process + Kern::Containers()[ EProcess ]->Wait(); + DProcess& process = *Kern::ProcessFromId( params().iProcessId ); + Kern::Containers()[ EProcess ]->Signal(); + + if ( NULL == &process ) + { + return KErrNotFound; + } + + // Temporary variable for collecting information from the library + TLibraryInfoBuf output; + + // Enters thread critical section and acquires code segment mutex. + Kern::AccessCode(); + + // Iterate to find the right library + if ( params().iIndex < process.iDynamicCode.Count() ) + { + // Acquire entry to the codeseg + SCodeSegEntry entry = process.iDynamicCode[ params().iIndex ]; + + // Acquire library information + entry.iLib->AppendName( output().iLibraryName );//lint !e64 !e1514 + output().iRunAddress = entry.iSeg->iRunAddress; + output().iSize = entry.iSeg->iSize; + + // Writes a descriptor to a thread's process. + error = Kern::ThreadDesWrite( aMessage.Client(), aLibraryInfo, output, 0 ); + + if ( KErrNone != error ) + { + LOGSTR2( "ATDD ThreadDesWrite error %d", error ); + } + + // Exits thread critical section and releases code segment mutex. + Kern::EndAccessCode(); + + return error; + } + else + { + // Exits thread critical section and releases code segment mutex. + Kern::EndAccessCode(); + + return KErrArgument; + } + } + +// ----------------------------------------------------------------------------- +// DAnalyzeToolChannel::MainThreadAllocator() +// Acquires information about process main thread RAllocator +// ----------------------------------------------------------------------------- +// +TInt DAnalyzeToolChannel::MainThreadAllocator( TAny* aMainThreadParams, + TThreadMessage& aMessage ) + { + LOGSTR1( "ATDD DAnalyzeToolChannel::MainThreadAllocator()" ); + + // Temporary variable for reading client side parameters + TMainThreadParamsBuf params; + + // Reads a descriptor from a thread's process. + TInt error = Kern::ThreadDesRead( aMessage.Client(), + aMainThreadParams, + params, + 0 ); + + if ( KErrNone != error ) + { + LOGSTR2( "ATDD ThreadDesRead error %d", error ); + return error; + } + + // Gets the current process + Kern::Containers()[ EProcess ]->Wait(); + DProcess& process = *Kern::ProcessFromId( params().iProcessId ); + Kern::Containers()[ EProcess ]->Signal(); + + if ( NULL == &process ) + { + return KErrNotFound; + } + + // Gets the current process + Kern::AccessCode(); + + // Temporary variable for collecting information from the RAllocator + TMainThreadParamsBuf output; + + // Aqcuire a reference to the main thread RAllocator + output().iAllocator = process.FirstThread()->iAllocator; + + // Is this only thread in the process + output().iAlone = process.iThreadQ.First()->Alone(); + + // Exits thread critical section and releases code segment mutex. + Kern::EndAccessCode(); + + // Writes a descriptor to a thread's process. + error = Kern::ThreadDesWrite( aMessage.Client(), + aMainThreadParams, + output, + 0 ); + + if ( KErrNone != error ) + { + LOGSTR2( "ATDD ThreadDesWrite error %d", error ); + } + + return error; + } + +// ----------------------------------------------------------------------------- +// DAnalyzeToolChannel::ThreadStack() +// Acquires main thread stack address +// ----------------------------------------------------------------------------- +// +TInt DAnalyzeToolChannel::ThreadStack( TAny* aThreadStack, + TThreadMessage& aMessage ) + { + LOGSTR1( "ATDD DAnalyzeToolChannel::ThreadStack()" ); + + // Temporary variable for reading client side parameters + TThreadParamsBuf params; + + // Reads a descriptor from a thread's process. + TInt error = Kern::ThreadDesRead( aMessage.Client(), + aThreadStack, + params, + 0 ); + + if ( KErrNone != error ) + { + LOGSTR2( "ATDD ThreadDesRead error %d", error ); + return error; + } + + // Gets the current process + Kern::Containers()[ EThread ]->Wait(); + DThread& thread = *Kern::ThreadFromId( params().iThreadId ); + Kern::Containers()[ EThread ]->Signal(); + + if ( NULL == &thread ) + { + return KErrNotFound; + } + + // Gets the current process + Kern::AccessCode(); + + // Temporary variable for collecting information from the RAllocator + TThreadParamsBuf output; + + // Stack address of the main thread + output().iStackAddress = thread.iUserStackRunAddress; + output().iStackSize = thread.iUserStackSize; + + // Exits thread critical section and releases code segment mutex. + Kern::EndAccessCode(); + + // Writes a descriptor to a thread's process. + error = Kern::ThreadDesWrite( aMessage.Client(), + aThreadStack, + output, + 0 ); + + if ( KErrNone != error ) + { + LOGSTR2( "ATDD ThreadDesWrite error %d", error ); + } + + return error; + } + +// ----------------------------------------------------------------------------- +// DAnalyzeToolChannel::GetProcessHandleInfo() +// Acquires information about process global handles +// ----------------------------------------------------------------------------- +// +TInt DAnalyzeToolChannel::GetProcessHandleInfo( TAny* aProcessHandleInfo, + TThreadMessage& aMessage ) + { + LOGSTR1( "ATDD DAnalyzeToolChannel::GetProcessHandleInfo()" ); + + // Temporary variable for collecting information from the codeseg + TProcessHandleInfoBuf params; + + // Reads a descriptor from a thread's process. + TInt error = Kern::ThreadDesRead( aMessage.Client(), + aProcessHandleInfo, + params, + 0 ); + + if ( KErrNone != error ) + { + LOGSTR2( "ATDD ThreadDesRead error %d", error ); + return error; + } + + // Gets the current process + Kern::Containers()[ EProcess ]->Wait(); + DProcess& process = *Kern::ProcessFromId( params().iProcessId ); + Kern::Containers()[ EProcess ]->Signal(); + + if ( NULL == &process ) + { + return KErrNotFound; + } + + // Variable holding wanted information + TProcessHandleInfoBuf output; + + // Enters thread critical section and acquires code segment mutex. + Kern::AccessCode(); + + // Get the process thread queue. + SDblQue queue = process.iThreadQ; + error = KErrNotFound; + + // Tests whether this doubly linked list is empty. + if ( !queue.IsEmpty() ) + { + // Gets a pointer to the first item in this doubly linked list. + SDblQueLink* link = queue.First(); + DThread* thread = _LOFF( link, DThread, iProcessLink ); + + if ( thread ) + { + +#ifdef MCL_ROBJECTIX + TInt threadHandles( thread->iHandles.ActiveCount() ); +#else + TInt threadHandles( thread->iHandles->ActiveCount() ); +#endif + + // Aqcuire thread information + //thread->AppendName( output.iThreadName ); + output().iUserStackRunAddress = thread->iUserStackRunAddress; + output().iUserStackSize = thread->iUserStackSize; + output().iThreadHandleCount = threadHandles; + +#ifdef MCL_ROBJECTIX + RObjectIx objectIx = process.iHandles; + output().iProcessHandleCount = objectIx.ActiveCount(); +#else + DObjectIx* objectIx = process.iHandles; + output().iProcessHandleCount = objectIx->ActiveCount(); +#endif + + // Writes a descriptor to a thread's process. + error = Kern::ThreadDesWrite( aMessage.Client(), + aProcessHandleInfo, + output, + 0 ); + + if ( KErrNone != error ) + { + LOGSTR2( "ATDD ThreadDesWrite error %d", error ); + } + } + } + + // Exits thread critical section and releases code segment mutex. + Kern::EndAccessCode(); + + return error; + } + +// ----------------------------------------------------------------------------- +// DAnalyzeToolChannel::GetCurrentHandleCount() +// Acquires a process's current handle count +// ----------------------------------------------------------------------------- +// +TInt DAnalyzeToolChannel::GetCurrentHandleCount( TAny* aProcessHandles, + TThreadMessage& aMessage ) + { + LOGSTR1( "ATDD DAnalyzeToolChannel::GetCurrentHandleCount()" ); + + // Temporary variable for collecting information from the codeseg + TATProcessHandlesBuf params; + + // Reads a descriptor from a thread's process. + TInt error = Kern::ThreadDesRead( aMessage.Client(), + aProcessHandles, + params, + 0 ); + + if ( KErrNone != error ) + { + LOGSTR2( "ATDD ThreadDesRead error %d", error ); + return error; + } + + // Gets the current process + Kern::Containers()[ EProcess ]->Wait(); + DProcess* process = Kern::ProcessFromId( params().iProcessId ); + Kern::Containers()[ EProcess ]->Signal(); + + if ( NULL == process ) + { + return KErrNotFound; + } + + // Variable holding wanted information + TATProcessHandlesBuf output; + + // Enters thread critical section and acquires code segment mutex. + Kern::AccessCode(); + + SDblQue queue = process->iThreadQ; + SDblQueLink* link = queue.First(); + TInt threadHandles( 0 ); + + // Iterate through current processes's threads + while ( link != queue.Last() ) + { + DThread* thread = _LOFF( link, DThread, iProcessLink ); + +#ifdef MCL_ROBJECTIX + threadHandles += thread->iHandles.ActiveCount(); +#else + threadHandles += thread->iHandles->ActiveCount(); +#endif + + link = link->iNext; + } + + if ( link == queue.Last() ) + { + DThread* thread = _LOFF( link, DThread, iProcessLink ); + +#ifdef MCL_ROBJECTIX + threadHandles += thread->iHandles.ActiveCount(); +#else + threadHandles += thread->iHandles->ActiveCount(); +#endif + } + + output().iCurrentHandleCount = threadHandles; + + // Writes a descriptor to a thread's process. + error = Kern::ThreadDesWrite( aMessage.Client(), + aProcessHandles, + output, + 0 ); + + if ( KErrNone != error ) + { + LOGSTR2( "ATDD ThreadDesWrite error %d", error ); + } + + // Exits thread critical section and releases code segment mutex. + Kern::EndAccessCode(); + + return error; + } + +// ----------------------------------------------------------------------------- +// DAnalyzeToolChannel::ClientCount() +// Acquires the count of current device driver users. +// ----------------------------------------------------------------------------- +// +TInt DAnalyzeToolChannel::ClientCount( TAny* aClientCount, + TThreadMessage& aMessage ) + { + LOGSTR1( "ATDD DAnalyzeToolChannel::ClientCount()" ); + + // Enters thread critical section and acquires code segment mutex. + Kern::AccessCode(); + + // Variable holding wanted information + TClientCountBuf output; + + // Get the number of DLogicalChannelBase objects currently in existence which + // have been created from this LDD. + output().iClientCount = DLogicalChannelBase::iDevice->iOpenChannels; + LOGSTR2( "ATDD > iOpenChannels count: %d", output().iClientCount ); + + // Writes a descriptor to a thread's process. + TInt error = Kern::ThreadDesWrite( aMessage.Client(), + aClientCount, + output, + 0 ); + + if ( KErrNone != error ) + { + LOGSTR2( "ATDD ThreadDesWrite error %d", error ); + } + + // Exits thread critical section and releases code segment mutex. + Kern::EndAccessCode(); + + return error; + } + +#ifdef __WINSCW__ +// ----------------------------------------------------------------------------- +// DAnalyzeToolChannel::GetModuleDependencies() +// Get module dependencies +// ----------------------------------------------------------------------------- +// +void DAnalyzeToolChannel::GetModuleDependencies( HMODULE aModule ) + { + LOGSTR1( "ATDD DAnalyzeToolChannel::GetModuleDependencies()" ); + + Emulator::TModule etm( aModule ); + TUint32 dllSize( 0 ); + // Temporary variable for collecting information from the codeseg + TCodesegInfo info; + TBool found( EFalse ); + + const IMAGE_IMPORT_DESCRIPTOR* imports = etm.Imports(); + while( imports->Characteristics != 0 ) + { + // Reset flag + found = EFalse; + + // Get dll name + const TUint8* nameAddr = ( const TUint8* )( imports->Name + ( TInt )etm.iBase ); + TPtrC8 namePtr( nameAddr ); + + // Get dll run address + Emulator::TModule imp_etm( ( PCSTR )etm.Translate( imports->Name ) ); + const TUint8* runAddr = ( const TUint8* )imp_etm.iBase; + + // Get dll size + const IMAGE_NT_HEADERS32* ntHeader = imp_etm.NtHeader(); + dllSize = ntHeader->OptionalHeader.SizeOfImage; + + // Check if DLL already exists in codesegment list + for( TInt i = 0; i < iCodeSeg.Count(); i++ ) + { + if ( iCodeSeg[i].iFullName.Compare( namePtr ) == KErrNone ) + { + found = ETrue; + break; + } + } + + if ( !found ) + { + info.iSize = dllSize; + info.iFullName.Copy( namePtr ); + info.iRunAddress = (TUint32) runAddr; + // Append codesegment to array + iCodeSeg.Append( info ); + } + imports++; + } + } + +#endif // __WINSCW__ + +// ----------------------------------------------------------------------------- +// DAnalyzeToolChannel::GetMemoryModel() +// Acquires memory model system uses. +// ----------------------------------------------------------------------------- +// +TInt DAnalyzeToolChannel::GetMemoryModel(TAny* aMemoryModel, + TThreadMessage& aMessage) + { + LOGSTR1( "ATDD DAnalyzeToolChannel::GetMemoryModel()" ); + + // Model buffer. + TATMemoryModelBuf model; + // Get current model. + model().iMemoryModel = (TUint32) Kern::HalFunction( EHalGroupKernel, EKernelHalMemModelInfo, NULL, NULL ); + model().iMemoryModel &= EMemModelTypeMask; // Mask out other stuff. + // Write it to client side. + TInt error = Kern::ThreadDesWrite( aMessage.Client(), + aMemoryModel, + model, + 0); + if ( error != KErrNone ) + { + LOGSTR2( "ATDD ThreadDesWrite error %d", error ); + } + return error; + } +// End of File diff -r d27dfa8884ad -r da2cedce4920 analyzetool/kerneleventhandler/src/analyzetooldevice.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/kerneleventhandler/src/analyzetooldevice.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,93 @@ +/* +* 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 DAnalyzeToolDevice. +* +*/ + + +// INCLUDE FILES +#include "analyzetooldevice.h" +#include "analyzetoolchannel.h" +#include "atlog.h" + +// ================= MEMBER FUNCTIONS ========================================= + +// ----------------------------------------------------------------------------- +// DAnalyzeToolDevice::DAnalyzeToolDevice() +// C++ default constructor. +// ----------------------------------------------------------------------------- +// +DAnalyzeToolDevice::DAnalyzeToolDevice() + { + LOGSTR1( "ATDD DAnalyzeToolDevice::DAnalyzeToolDevice()" ); + // Set version number + iVersion = KAnalyzeToolLddVersion(); + } + +// ----------------------------------------------------------------------------- +// DAnalyzeToolDevice::Install() +// Second stage constructor. +// ----------------------------------------------------------------------------- +// +TInt DAnalyzeToolDevice::Install() + { + LOGSTR1( "ATDD DAnalyzeToolDevice::Install()" ); + // Set device name + return SetName( &KAnalyzeToolLddName ); + } + +// ----------------------------------------------------------------------------- +// DAnalyzeToolDevice::GetCaps() +// Gets the driver's capabilities. +// ----------------------------------------------------------------------------- +// +void DAnalyzeToolDevice::GetCaps( TDes8& /*aDes*/ ) const + { + LOGSTR1( "ATDD DAnalyzeToolDevice::GetCaps()" ); + } + +// ----------------------------------------------------------------------------- +// DAnalyzeToolDevice::Create() +// Creates the logical channel. +// ----------------------------------------------------------------------------- +// +TInt DAnalyzeToolDevice::Create( DLogicalChannelBase*& aChannel ) + { + LOGSTR1( "ATDD DAnalyzeToolDevice::Create()" ); + + // create new channel + aChannel = new DAnalyzeToolChannel; + + // check that everything is OK + return ( aChannel != NULL ) ? KErrNone : KErrNoMemory; + } + +// ----------------------------------------------------------------------------- +// DECLARE_STANDARD_LDD +// Defines the entry point for a standard logical device driver (LDD), +// and declares the ordinal 1 export function for creating +// the LDD factory object +// ----------------------------------------------------------------------------- +// +DECLARE_STANDARD_LDD() + { + LOGSTR1( "ATDD DECLARE_STANDARD_LDD()" ); + return new DAnalyzeToolDevice; + } + +// ================= OTHER EXPORTED FUNCTIONS ================================= + +// None + +// End of File diff -r d27dfa8884ad -r da2cedce4920 analyzetool/kerneleventhandler/src/analyzetooleventhandler.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/kerneleventhandler/src/analyzetooleventhandler.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,427 @@ +/* +* 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 DAnalyzeToolEventHandler. +* +*/ + + +// INCLUDE FILES +#include "analyzetooleventhandler.h" +#include + +// CONSTANTS + +// The handler mutex literal +_LIT( KHandlerMutexName, "AnalyzeToolHandlerMutex" ); + +// The handle data mutex literal +_LIT( KDataMutexName, "AnalyzeToolDataMutex" ); + + +// ================= MEMBER FUNCTIONS ========================================= + +// ----------------------------------------------------------------------------- +// DAnalyzeToolEventHandler::Create() +// C++ default constructor. +// ----------------------------------------------------------------------------- +// +TInt DAnalyzeToolEventHandler::Create( DLogicalDevice* aDevice, + const TUint aProcessId ) + { + LOGSTR1( "ATDD DAnalyzeToolEventHandler::Create()" ); + TInt ret( KErrNone ); + + // Store owner process ID + iProcessId = aProcessId; + LOGSTR2( "ATDD DAnalyzeToolEventHandler::Create > iProcessId %d", + iProcessId ); + + // Open the device + ret = aDevice->Open(); + if ( ret != KErrNone ) + return ret; + iDevice = aDevice; + + // Create mutex for the handler + ret = Kern::MutexCreate( iHandlerMutex, KHandlerMutexName, KMutexOrdDebug ); + if ( ret != KErrNone ) + return ret; + // Create mutex for the data + ret = Kern::MutexCreate( iDataMutex, KDataMutexName, KMutexOrdDebug-1 ); + if ( ret != KErrNone ) + return ret; + + // Add handler to the handler queue + return Add(); + } + +// ----------------------------------------------------------------------------- +// DAnalyzeToolEventHandler::~DAnalyzeToolEventHandler() +// C++ default constructor. +// ----------------------------------------------------------------------------- +// +DAnalyzeToolEventHandler::~DAnalyzeToolEventHandler() + { + LOGSTR1( "ATDD DAnalyzeToolEventHandler::~DAnalyzeToolEventHandler()" ); + + CancelInformLibraryEvent(); + + // Close the data mutex + if ( iDataMutex ) + { + iDataMutex->Close( NULL ); + } + + // Close the handler mutex + if ( iHandlerMutex ) + { + iHandlerMutex->Close( NULL ); + } + + // Close the device mutex + if ( iDevice ) + { + iDevice->Close( NULL ); + } + } + +// ----------------------------------------------------------------------------- +// DAnalyzeToolEventHandler::EventHandler() +// Function for receiving kernel events +// ----------------------------------------------------------------------------- +// +TUint DAnalyzeToolEventHandler::EventHandler( TKernelEvent aEvent, + TAny* a1, TAny* a2, TAny* aThis ) + { + + // Clarify the event type + switch ( aEvent) + { + case EEventRemoveLibrary: + { + LOGSTR1( "ATDD DAnalyzeToolEventHandler::EventHandler() - EEventRemoveLibrary" ); + // Cast the pointer to the handler + DAnalyzeToolEventHandler* handler = + ( ( DAnalyzeToolEventHandler* ) aThis ); + // Create variable for library information + TLibraryEventInfo info; + // Set as library remove event + info.iEventType = TLibraryEventInfo::ELibraryRemoved; + // Handle the event + handler->HandleLibraryEvent( ( DLibrary* ) a1, ( DThread* ) a2, info ); + break; + } + case EEventAddLibrary: + { + LOGSTR1( "ATDD DAnalyzeToolEventHandler::EventHandler() - EEventAddLibrary" ); + // Cast the pointer to the handler + DAnalyzeToolEventHandler* handler = + ( ( DAnalyzeToolEventHandler* ) aThis ); + // Create variable for library information + TLibraryEventInfo info; + // Set as library remove event + info.iEventType = TLibraryEventInfo::ELibraryAdded; + // Handle the event + handler->HandleLibraryEvent( ( DLibrary* ) a1, ( DThread* ) a2, info ); + break; + } + case EEventHwExc: + { + LOGSTR1( "ATDD DAnalyzeToolEventHandler::EventHandler() - EEventHwExc" ); + break; + } + case EEventSwExc: + { + LOGSTR1( "ATDD DAnalyzeToolEventHandler::EventHandler() - EEventSwExc" ); + break; + } + case EEventRemoveThread: + { + LOGSTR1( "ATDD DAnalyzeToolEventHandler::EventHandler() - EEventRemoveThread" ); + break; + } + case EEventKillThread: + { + LOGSTR1( "ATDD DAnalyzeToolEventHandler::EventHandler() - EEventKillThread" ); + + // Cast the pointer to the handler + DAnalyzeToolEventHandler* handler = + ( ( DAnalyzeToolEventHandler* ) aThis ); + + // Create variable for library information + TLibraryEventInfo info; + + // Set as kill thread event + info.iEventType = TLibraryEventInfo::EKillThread; + // Handle the event + handler->HandleKillThreadEvent( ( DThread* ) a1, info ); + break; + } + default: + { + } + break; + } + return ERunNext; + } + +// ----------------------------------------------------------------------------- +// DAnalyzeToolEventHandler::HandleLibraryEvent() +// Handles the EEventAddLibrary and EEventRemoveLibrary events. +// ----------------------------------------------------------------------------- +// +void DAnalyzeToolEventHandler::HandleLibraryEvent( DLibrary* aLib, + DThread* aThread, TLibraryEventInfo& aInfo ) + { + LOGSTR1( "ATDD DAnalyzeToolEventHandler::HandleLibraryEvent()" ); + + // Aqcuire the handler mutex + Kern::MutexWait( *iHandlerMutex ); + + // Aqcuire the data mutex + Kern::MutexWait( *iDataMutex ); + + TBool addInfo( EFalse ); + + // Check the library event type + if ( aInfo.iEventType == TLibraryEventInfo::ELibraryAdded ) + { + if ( aThread != NULL ) + { + if ( iProcessId == aThread->iOwningProcess->iId ) + { + LOGSTR1( "ATDD > Process id match" ); + aInfo.iProcessId = aThread->iOwningProcess->iId; + addInfo = ETrue; + } + } + } + else if ( aInfo.iEventType == TLibraryEventInfo::ELibraryRemoved ) + { + if ( aThread != NULL ) + { + aInfo.iProcessId = aThread->iOwningProcess->iId; + } + else + { + aInfo.iProcessId = 0; + } + addInfo = ETrue; + } + + if ( addInfo ) + { + // Store lib info + aLib->AppendName( aInfo.iLibraryName );//lint !e64 !e1514 + aInfo.iSize = aLib->iCodeSeg->iSize; + aInfo.iRunAddress = aLib->iCodeSeg->iRunAddress; + // Store library event info to the array + iEventArray.Append( aInfo ); + LOGSTR2( "ATDD > iEventArray.Count() = %d", iEventArray.Count() ); + + // if client has subscribed the event it is queued + if ( iClientThread != NULL ) + { + iEventDfc.Enque(); + } + } + + // Release the data mutex + Kern::MutexSignal( *iDataMutex ); + + // Release the handler mutex + Kern::MutexSignal( *iHandlerMutex ); + } + +// ----------------------------------------------------------------------------- +// DAnalyzeToolEventHandler::InformLibraryEvent() +// Subscribes library event. +// ----------------------------------------------------------------------------- +// +void DAnalyzeToolEventHandler::InformLibraryEvent( TRequestStatus* aStatus, + TAny* aLibraryInfo, + TThreadMessage& aMessage ) + { + LOGSTR1( "ATDD DAnalyzeToolEventHandler::InformLibraryEvent()" ); + + // Aqcuire the data mutex + Kern::MutexWait( *iDataMutex ); + + // Check if request from client which is already pending + DThread* current = aMessage.Client(); + + LOGSTR2( "ATDD > Current Thread ID = %d", current->iId ); + + // Ensure that client doesn't subscribe service when there is a pending + // subscription + if ( NULL != iClientThread ) + { + aMessage.PanicClient( KClientPanic, EPanicRequestPending ); + } + else + { + // Store the client variable pointers + iClientThread = current; + iClientRequestStatus = aStatus; + iClientInfo = aLibraryInfo; + } + + // Release the data mutex + Kern::MutexSignal( *iDataMutex ); + + // Queue the event since now the client has subscribed it + iEventDfc.Enque(); + } + +// ----------------------------------------------------------------------------- +// DAnalyzeToolEventHandler::CancelInformLibraryEvent +// Cancels subscription of the library event. +// ----------------------------------------------------------------------------- +// +void DAnalyzeToolEventHandler::CancelInformLibraryEvent() + { + LOGSTR1( "ATDD DAnalyzeToolEventHandler::CancelInformLibraryEvent()" ); + + iEventDfc.Cancel(); + + // Aqcuire the data mutex + Kern::MutexWait( *iDataMutex ); + + if ( NULL != iClientThread && iEventArray.Count() > 0 ) + { + // Signal the request as complete + Kern::RequestComplete( iClientThread, + iClientRequestStatus, + KErrCancel ); + + iClientThread = NULL; + iClientRequestStatus = NULL; + iClientInfo = NULL; + + // Reset the event array + iEventArray.Reset(); + } + + // Release the data mutex + Kern::MutexSignal( *iDataMutex ); + } + +// ----------------------------------------------------------------------------- +// DAnalyzeToolEventHandler::HandleKillThreadEvent() +// Handles the EEventKillThread events. +// ----------------------------------------------------------------------------- +// +void DAnalyzeToolEventHandler::HandleKillThreadEvent( DThread* aThread, + TLibraryEventInfo& aInfo ) + { + LOGSTR1( "ATDD DAnalyzeToolEventHandler::HandleKillThreadEvent()" ); + + // Aqcuire the handler mutex + Kern::MutexWait( *iHandlerMutex ); + + // Aqcuire the data mutex + Kern::MutexWait( *iDataMutex ); + + aInfo.iProcessId = aThread->iOwningProcess->iId; + TBool alone( aThread->iOwningProcess->iThreadQ.First()->Alone() ); + LOGSTR2( "ATDD > Is alone = %d", alone ); + + // Check if this our process and is the only thread item. + if ( aInfo.iProcessId == iProcessId && !alone ) + { + if ( aThread ) + { + // Set current Thread id + LOGSTR2( "ATDD > Thread ID = %d", aThread->iId ); + aInfo.iThreadId = aThread->iId; + // Append event to array (beginning of the array) + iEventArray.Insert( aInfo, 0 ); + + // if client has subscribed the event it is queued + if ( iClientThread != NULL ) + { + iEventDfc.Enque(); + } + } + } + + // Release the data mutex + Kern::MutexSignal( *iDataMutex ); + + // Release the handler mutex + Kern::MutexSignal( *iHandlerMutex ); + } + +// ----------------------------------------------------------------------------- +// DAnalyzeToolEventHandler::DoEventComplete() +// Informs client about the occured event. +// ----------------------------------------------------------------------------- +// +void DAnalyzeToolEventHandler::DoEventComplete() + { + LOGSTR1( "ATDD DAnalyzeToolEventHandler::DoEventComplete()" ); + + // Aqcuire the handler mutex + Kern::MutexWait( *iHandlerMutex ); + + // Aqcuire the data mutex + Kern::MutexWait( *iDataMutex ); + + if ( NULL != iClientThread && iEventArray.Count() > 0 ) + { + TInt ret = Kern::ThreadRawWrite( iClientThread, + iClientInfo, + &iEventArray[0], + sizeof( iEventArray[0] ) ); + + LOGSTR2( "ATDD > ThreadRawWrite err = %d", ret ); + + // Signal the request as complete + Kern::RequestComplete( iClientThread, + iClientRequestStatus, + ret ); + + // Remove first item to array + iEventArray.Remove( 0 ); + + // Compresses the array down to a minimum + iEventArray.Compress(); + + // Ensure that pointers are set to NULL + iClientThread = NULL; + iClientRequestStatus = NULL; + iClientInfo = NULL; + + LOGSTR2( "ATDD > iEventArray = %d", iEventArray.Count() ); + } + + // Release the data mutex + Kern::MutexSignal( *iDataMutex ); + + // Release the handler mutex + Kern::MutexSignal( *iHandlerMutex ); + } + +// ----------------------------------------------------------------------------- +// DAnalyzeToolEventHandler::EventDfc() +// Static function for DFC events. +// ----------------------------------------------------------------------------- +// +void DAnalyzeToolEventHandler::EventDfc(TAny* aPtr) + { + LOGSTR1( "ATDD DAnalyzeToolEventHandler::EventDfc()" ); + ( (DAnalyzeToolEventHandler*) aPtr )->DoEventComplete(); + } + +// End of File diff -r d27dfa8884ad -r da2cedce4920 analyzetool/rom/analyzetool.iby --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/rom/analyzetool.iby Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,25 @@ +/* +* Copyright (c) 2008 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: +* +*/ + + +#ifndef __ANALYZETOOL_IBY__ +#define __ANALYZETOOL_IBY__ + +// Stub +data=ZSYSTEM\Install\analyzetool_stub.sis \system\install\analyzetool_stub.sis + +#endif // __ANALYZETOOL_IBY__ diff -r d27dfa8884ad -r da2cedce4920 analyzetool/rom/analyzetool_rom.iby --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/rom/analyzetool_rom.iby Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,37 @@ +/* +* Copyright (c) 2008 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: +* +*/ + + +#ifndef __ANALYZETOOL_ROM_IBY__ +#define __ANALYZETOOL_ROM_IBY__ + + +// Kernel event handler +device[VARID]=ABI_DIR\BUILD_DIR\atoolkerneleventhandler.ldd SHARED_LIB_DIR\atoolkerneleventhandler.ldd + +// Memory hook +file=ABI_DIR\BUILD_DIR\atoolmemoryhook.dll SHARED_LIB_DIR\atoolmemoryhook.dll + +// Cleaner +file=ABI_DIR\BUILD_DIR\atoolcleaner.dll SHARED_LIB_DIR\atoolcleaner.dll + +// Storage server +file=ABI_DIR\BUILD_DIR\atoolstorageserver.exe PROGRAMS_DIR\atoolstorageserver.exe +file=ABI_DIR\BUILD_DIR\atoolstorageserverclnt.dll SHARED_LIB_DIR\atoolstorageserverclnt.dll + + +#endif // __ANALYZETOOL_ROM_IBY__ diff -r d27dfa8884ad -r da2cedce4920 analyzetool/sis/AnalyzeTool.pkg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/sis/AnalyzeTool.pkg Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,42 @@ +; +; 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: +; + +;Language - standard language definitions +&EN + +; standard SIS file header +#{"AnalyzeTool"},(0x20012432),1,9,1,TYPE=SA, RU + +;Localised Vendor name +%{"Nokia Corporation"} + +;Unique Vendor name +:"Nokia Corporation" + +;Supports Series 60 v 3.1 +[0x102032BE], 0, 0, 0, {"Series60ProductID"} + +;Supports S60 release 5.0 +[0x1028315F], 0, 0, 0, {"Series60ProductID"} + +"\epoc32\release\armv5\urel\atoolkerneleventhandler.ldd" -"!:\sys\bin\atoolkerneleventhandler.ldd" +"\epoc32\release\armv5\urel\atoolmemoryhook.dll" -"!:\sys\bin\atoolmemoryhook.dll" +"\epoc32\release\armv5\urel\atoolstorageserver.exe" -"!:\sys\bin\atoolstorageserver.exe" +"\epoc32\release\armv5\urel\atoolstorageserverclnt.dll" -"!:\sys\bin\atoolstorageserverclnt.dll" +"\epoc32\release\armv5\urel\atoolcleaner.dll" -"!:\sys\bin\atoolcleaner.dll" + +; Install console application +"\epoc32\release\armv5\urel\atool.exe"-"!:\sys\bin\atool.exe" \ No newline at end of file diff -r d27dfa8884ad -r da2cedce4920 analyzetool/sis/AnalyzeTool_udeb.pkg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/sis/AnalyzeTool_udeb.pkg Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,42 @@ +; +; 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: +; + +;Language - standard language definitions +&EN + +; standard SIS file header +#{"AnalyzeTool"},(0x20012432),1,9,1,TYPE=SA, RU + +;Localised Vendor name +%{"Nokia Corporation"} + +;Unique Vendor name +:"Nokia Corporation" + +;Supports Series 60 v 3.1 +[0x102032BE], 0, 0, 0, {"Series60ProductID"} + +;Supports S60 release 5.0 +[0x1028315F], 0, 0, 0, {"Series60ProductID"} + +"\epoc32\release\armv5\udeb\atoolkerneleventhandler.ldd" -"!:\sys\bin\atoolkerneleventhandler.ldd" +"\epoc32\release\armv5\udeb\atoolmemoryhook.dll" -"!:\sys\bin\atoolmemoryhook.dll" +"\epoc32\release\armv5\udeb\atoolstorageserver.exe" -"!:\sys\bin\atoolstorageserver.exe" +"\epoc32\release\armv5\udeb\atoolstorageserverclnt.dll" -"!:\sys\bin\atoolstorageserverclnt.dll" +"\epoc32\release\armv5\urel\atoolcleaner.dll" -"!:\sys\bin\atoolcleaner.dll" + +; Install console application +"\epoc32\release\armv5\udeb\atool.exe"-"!:\sys\bin\atool.exe" \ No newline at end of file diff -r d27dfa8884ad -r da2cedce4920 analyzetool/sis/analyzeTool_stub.pkg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/sis/analyzeTool_stub.pkg Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,36 @@ +; +; 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: +; + +;Languages +&EN + +;Header +#{"AnalyzeTool"}, (0x20012432), 1,9,1 + +; Non-localised vendor name +:"Nokia Corporation" + +; Localised vendor names +%{"Nokia Corporation"} + +; AnalyzeTool binaries +""-"z:\sys\bin\atoolkerneleventhandler.ldd" +""-"z:\sys\bin\atoolmemoryhook.dll" +""-"z:\sys\bin\atoolstorageserver.exe" +""-"z:\sys\bin\atoolstorageserverclnt.dll" +""-"z:\sys\bin\atoolcleaner.dll" + +""-"z:\sys\bin\atool.exe" \ No newline at end of file diff -r d27dfa8884ad -r da2cedce4920 analyzetool/staticlib/group/atoolstaticlib.mmp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/staticlib/group/atoolstaticlib.mmp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,34 @@ +/* +* 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: The .mmp file for AToolStaticLib. +* +*/ + +#include + +TARGET atoolstaticlib.lib +TARGETTYPE lib +UID 0x1000008d 0x20018421//0x02DF7F96 +CAPABILITY ALL -TCB + +SMPSAFE + +USERINCLUDE ../../inc +SOURCEPATH ../src +SOURCE atoolstaticlib.cpp + +OS_LAYER_SYSTEMINCLUDE + + + diff -r d27dfa8884ad -r da2cedce4920 analyzetool/staticlib/group/bld.inf --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/staticlib/group/bld.inf Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,27 @@ +/* +* 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: +* +*/ + +#include + +PRJ_PLATFORMS +ARMV5 WINSCW + +PRJ_EXPORTS +../../dynamicmemoryhook/inc/customuser.h OS_LAYER_PLATFORM_EXPORT_PATH(analyzetool/customuser.h) + +PRJ_MMPFILES +atoolstaticlib.mmp diff -r d27dfa8884ad -r da2cedce4920 analyzetool/staticlib/src/atoolstaticlib.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/staticlib/src/atoolstaticlib.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,122 @@ +/* +* 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: The file contains declarations of extern methods and definitions +* of overloaded User methods. +* +*/ + + +#include +#include "atlog.h" + +// ----------------------------------------------------------------------------- +// GetInt() +// Extern function for acquiring all integer values +// ----------------------------------------------------------------------------- +// +GLREF_C TInt GetInt( const TUint8 aType ); + +// ----------------------------------------------------------------------------- +// GetString() +// Extern function for acquiring all string values +// ----------------------------------------------------------------------------- +// +GLREF_C TPtrC GetString( const TUint8 aType ); + +// ----------------------------------------------------------------------------- +// User::Exit() +// Overloaded User::Exit() function +// ----------------------------------------------------------------------------- +// +void User::Exit( TInt aReason ) + { + LOGSTR2( "ATMH User::Exit %i", aReason ); + CustomUser::Exit( aReason ); + } + +// ----------------------------------------------------------------------------- +// User::Panic() +// Overloaded User::Panic() function +// ----------------------------------------------------------------------------- +// +void User::Panic( const TDesC& aCategory, TInt aReason ) + { + LOGSTR3( "ATMH User::Panic() %S %i", &aCategory, aReason ); + CustomUser::Panic( aCategory, aReason ); + } + +// ----------------------------------------------------------------------------- +// User::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. +// ----------------------------------------------------------------------------- +// +TInt User::SetCritical( TCritical aCritical ) + { + LOGSTR2( "ATMH User::SetCritical() %i", aCritical ); + return CustomUser::SetCritical( aCritical ); + } + +// ----------------------------------------------------------------------------- +// User::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. +// ----------------------------------------------------------------------------- +// +TInt User::SetProcessCritical( TCritical aCritical ) + { + LOGSTR2( "ATMH User::SetProcessCritical() %i", aCritical ); + return CustomUser::SetProcessCritical( aCritical ); + } + +// ----------------------------------------------------------------------------- +// UserHeap::SetupThreadHeap() +// Overloaded UserHeap::SetupThreadHeap function +// ----------------------------------------------------------------------------- +// +TInt UserHeap::SetupThreadHeap( TBool aNotFirst, + SStdEpocThreadCreateInfo& aInfo ) + { + LOGSTR1( "ATMH UserHeap::SetupThreadHeap()" ); + + // Check validity of parameters + TInt logOption( GetInt( (TUint8) CustomUser::ELogOption ) ); + if ( logOption < 0 ) + logOption = KATDefaultLogOption; + + TInt debug( GetInt( (TUint8) CustomUser::EDebug ) ); + if ( debug < 0 ) + debug = KATDefaultDebug; + + TInt allocCallStack( GetInt( (TUint8) CustomUser::EAllocCallStackSize ) ); + if ( allocCallStack < 0 ) + allocCallStack = KATDefaultAllocCallStackSize; + + TInt freeCallStack( GetInt( (TUint8) CustomUser::EFreeCallStackSize ) ); + if ( freeCallStack < 0 ) + freeCallStack = KATDefaultFreeCallStackSize; + + return CustomUser::SetupThreadHeap( aNotFirst, aInfo, + GetString( (TUint8) CustomUser::ELogFileName ), + (TUint32) logOption, (TUint32) debug, + GetString( (TUint8) CustomUser::EVersion ), + (TUint32) allocCallStack, (TUint32) freeCallStack, + KATArgumentList ); + } + +// End of File diff -r d27dfa8884ad -r da2cedce4920 analyzetool/storageserver/client/bwins/atoolstorageserverclntu.def --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/storageserver/client/bwins/atoolstorageserverclntu.def Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,26 @@ +EXPORTS + ??0RATStorageServer@@QAE@XZ @ 1 NONAME ; RATStorageServer::RATStorageServer(void) + ?CancelLogging@RATStorageServer@@QAEHI@Z @ 2 NONAME ; int RATStorageServer::CancelLogging(unsigned int) + ?CheckMemoryAddress@RATStorageServer@@QBEHK@Z @ 3 NONAME ; int RATStorageServer::CheckMemoryAddress(unsigned long) const + ?Close@RATStorageServer@@QAEXXZ @ 4 NONAME ; void RATStorageServer::Close(void) + ?Connect@RATStorageServer@@QAEHXZ @ 5 NONAME ; int RATStorageServer::Connect(void) + ?GetCurrentAllocsL@RATStorageServer@@QAEHIAAK0@Z @ 6 NONAME ; int RATStorageServer::GetCurrentAllocsL(unsigned int, unsigned long &, unsigned long &) + ?GetLoadedDllsL@RATStorageServer@@QAEHIAAV?$RArray@V?$TBuf8@$0DM@@@@@@Z @ 7 NONAME ; int RATStorageServer::GetLoadedDllsL(unsigned int, class RArray > &) + ?GetLoggingFileL@RATStorageServer@@QAEHIAAVTDes8@@@Z @ 8 NONAME ; int RATStorageServer::GetLoggingFileL(unsigned int, class TDes8 &) + ?GetLoggingModeL@RATStorageServer@@QAEHIAAW4TATLogOption@@@Z @ 9 NONAME ; int RATStorageServer::GetLoggingModeL(unsigned int, enum TATLogOption &) + ?GetMaxAllocsL@RATStorageServer@@QAEHIAAK0@Z @ 10 NONAME ; int RATStorageServer::GetMaxAllocsL(unsigned int, unsigned long &, unsigned long &) + ?GetProcessesL@RATStorageServer@@QAEHAAV?$RArray@VTATProcessInfo@@@@@Z @ 11 NONAME ; int RATStorageServer::GetProcessesL(class RArray &) + ?GetUdebL@RATStorageServer@@QAEHIAAK@Z @ 12 NONAME ; int RATStorageServer::GetUdebL(unsigned int, unsigned long &) + ?IsMemoryAdded@RATStorageServer@@QAEHK@Z @ 13 NONAME ; int RATStorageServer::IsMemoryAdded(unsigned long) + ?LogDllLoaded@RATStorageServer@@QAEHABVTDesC8@@KK@Z @ 14 NONAME ; int RATStorageServer::LogDllLoaded(class TDesC8 const &, unsigned long, unsigned long) + ?LogDllUnloaded@RATStorageServer@@QAEHABVTDesC8@@KK@Z @ 15 NONAME ; int RATStorageServer::LogDllUnloaded(class TDesC8 const &, unsigned long, unsigned long) + ?LogMemoryAllocated@RATStorageServer@@QAEHKAAV?$TFixedArray@K$0BAA@@@H@Z @ 16 NONAME ; int RATStorageServer::LogMemoryAllocated(unsigned long, class TFixedArray &, int) + ?LogMemoryFreed@RATStorageServer@@QAEHKAAV?$TFixedArray@K$0BAA@@@@Z @ 17 NONAME ; int RATStorageServer::LogMemoryFreed(unsigned long, class TFixedArray &) + ?LogProcessEnded@RATStorageServer@@QAEHII@Z @ 18 NONAME ; int RATStorageServer::LogProcessEnded(unsigned int, unsigned int) + ?LogProcessStarted@RATStorageServer@@QAEHABVTDesC16@@ABVTDesC8@@IKK@Z @ 19 NONAME ; int RATStorageServer::LogProcessStarted(class TDesC16 const &, class TDesC8 const &, unsigned int, unsigned long, unsigned long) + ?StartSubTest@RATStorageServer@@QAEHABVTDesC8@@@Z @ 20 NONAME ; int RATStorageServer::StartSubTest(class TDesC8 const &) + ?StartSubTest@RATStorageServer@@QAEHIABVTDesC8@@H@Z @ 21 NONAME ; int RATStorageServer::StartSubTest(unsigned int, class TDesC8 const &, int) + ?StopSubTest@RATStorageServer@@QAEHABVTDesC8@@@Z @ 22 NONAME ; int RATStorageServer::StopSubTest(class TDesC8 const &) + ?StopSubTest@RATStorageServer@@QAEHIABVTDesC8@@H@Z @ 23 NONAME ; int RATStorageServer::StopSubTest(unsigned int, class TDesC8 const &, int) + ?Version@RATStorageServer@@QBE?AVTVersion@@XZ @ 24 NONAME ; class TVersion RATStorageServer::Version(void) const + diff -r d27dfa8884ad -r da2cedce4920 analyzetool/storageserver/client/eabi/atoolstorageserverclntu.def --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/storageserver/client/eabi/atoolstorageserverclntu.def Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,27 @@ +EXPORTS + _ZN16RATStorageServer11StopSubTestERK6TDesC8 @ 1 NONAME + _ZN16RATStorageServer11StopSubTestEjRK6TDesC8i @ 2 NONAME + _ZN16RATStorageServer12LogDllLoadedERK6TDesC8mm @ 3 NONAME + _ZN16RATStorageServer12StartSubTestERK6TDesC8 @ 4 NONAME + _ZN16RATStorageServer12StartSubTestEjRK6TDesC8i @ 5 NONAME + _ZN16RATStorageServer13CancelLoggingEj @ 6 NONAME + _ZN16RATStorageServer13GetMaxAllocsLEjRmS0_ @ 7 NONAME + _ZN16RATStorageServer13GetProcessesLER6RArrayI14TATProcessInfoE @ 8 NONAME + _ZN16RATStorageServer13IsMemoryAddedEm @ 9 NONAME + _ZN16RATStorageServer14GetLoadedDllsLEjR6RArrayI5TBuf8ILi60EEE @ 10 NONAME + _ZN16RATStorageServer14LogDllUnloadedERK6TDesC8mm @ 11 NONAME + _ZN16RATStorageServer14LogMemoryFreedEmR11TFixedArrayImLi256EE @ 12 NONAME + _ZN16RATStorageServer15GetLoggingFileLEjR5TDes8 @ 13 NONAME + _ZN16RATStorageServer15GetLoggingModeLEjR12TATLogOption @ 14 NONAME + _ZN16RATStorageServer15LogProcessEndedEjj @ 15 NONAME + _ZN16RATStorageServer17GetCurrentAllocsLEjRmS0_ @ 16 NONAME + _ZN16RATStorageServer17LogProcessStartedERK7TDesC16RK6TDesC8jmm @ 17 NONAME + _ZN16RATStorageServer18LogMemoryAllocatedEmR11TFixedArrayImLi256EEi @ 18 NONAME + _ZN16RATStorageServer5CloseEv @ 19 NONAME + _ZN16RATStorageServer7ConnectEv @ 20 NONAME + _ZN16RATStorageServer8GetUdebLEjRm @ 21 NONAME + _ZN16RATStorageServerC1Ev @ 22 NONAME + _ZN16RATStorageServerC2Ev @ 23 NONAME + _ZNK16RATStorageServer18CheckMemoryAddressEm @ 24 NONAME + _ZNK16RATStorageServer7VersionEv @ 25 NONAME + diff -r d27dfa8884ad -r da2cedce4920 analyzetool/storageserver/client/group/atoolstorageserverclnt.mmp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/storageserver/client/group/atoolstorageserverclnt.mmp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,41 @@ +/* +* 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: The .mmp file for the client side of AToolStorageServer +* +*/ + +#include + +TARGET atoolstorageserverclnt.dll +TARGETTYPE dll +UID 0x1000008d 0x20012431 +CAPABILITY ALL -TCB + +SMPSAFE + +SOURCEPATH ../src + +SOURCE atstorageserverclnt.cpp + +USERINCLUDE ../inc +USERINCLUDE ../../inc +USERINCLUDE ../../server/inc +USERINCLUDE ../../../inc + +OS_LAYER_SYSTEMINCLUDE + +LIBRARY euser.lib +LIBRARY flogger.lib + +// End of File diff -r d27dfa8884ad -r da2cedce4920 analyzetool/storageserver/client/inc/atstorageserverclnt.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/storageserver/client/inc/atstorageserverclnt.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,371 @@ +/* +* 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: Declaration of the client side handle class RATStorageServer +* +*/ + + + +#ifndef ATSTORAGESERVERCLNT_H +#define ATSTORAGESERVERCLNT_H + + +// INCLUDES +#include +#include + + +// CONSTANTS +// Constants for the lowest version of the server with which the +// client is compatible +const TUint KLowestVersionNumberMaj = 0; +const TUint KLowestVersionNumberMin = 1; +const TUint KLowestVersionNumberBld = 1; + + +// FORWARD DECLARATIONS +class TATProcessInfo; + + +// CLASS DECLARATION + +/** +* The main class of the Storage Server client. Objects of this class work as handles +* to the Storage Server's server side. Use Connect() to connect a client to the server, +* and Close() to end an opened session. +*/ +class RATStorageServer: public RSessionBase + { + public: // Constructor and destructor + + /** + * C++ default constructor. + */ + IMPORT_C RATStorageServer(); + + public: // New functions + + /** + * Creates a new process for the server, if that doesn't already exist, and + * connects a client to the server by creating a new session with it, and + * initializes the client for use. To end the server session, use Close(). + * @return KErrNone, if successful; otherwise one of the other + * system-wide error codes. + */ + IMPORT_C TInt Connect(); + + /** + * Closes a handle to a server session. This has also the effect of destroying + * the associated server side session object. Also, the server itself and the + * process where it is running are destroyed, if there are no other open sessions + * left. + */ + IMPORT_C void Close(); + + /** + * This method is called to initialize the server for logging and it is to be + * called as the first method after connecting to the server. The method informs + * the server that a new process has been started. The method cannot be called + * again without a call to the LogProcessEnded() first. Otherwise a STSEClient: 3 + * panic is raised. A KERN-EXEC: 0 panic is raised if the client is not connected + * to the server. + * @param aFileName The name of the logging file used when the system is logging + * to a file (the logging mode is EATLogToFile). The length of aFileName must not be + * greater than KMaxFileName, otherwise the method raises a STSEClient: 2 panic. + * @param aProcessName The name of the new process started. The length of this + * descriptor must not be greater than KMaxProcessName, otherwise the method + * raises a STSEClient: 2 panic. + * @param aProcessId The ID of the process started. + * @param aLogOption An option telling the logging mode. + * @param aIsDebug Determines whether a binary is UDEB or UREL + * @return KErrNone, if successful; otherwise one of the other + * system-wide error codes. + */ + IMPORT_C TInt LogProcessStarted( const TDesC& aFileName, + const TDesC8& aProcessName, + TUint aProcessId, + TUint32 aLogOption, TUint32 aIsDebug ); + + /** + * Asks the server to log that a new DLL has been loaded. Note, the method + * LogProcessStarted() has to be previously called. Otherwise a STSEClient: 3 + * panic is raised. A KERN-EXEC: 0 panic is raised if the client is not connected + * to the server. + * @param aDllName The name of the new DLL loaded. The length of this descriptor + * must not be greater than KMaxLibraryName, otherwise the method raises a + * STSEClient: 2 panic. + * @param aStartAddress The start address of the DLL loaded. + * @param aEndAddress The end address of the DLL loaded. + * @return KErrNone, if successful; otherwise one of the other + * system-wide error codes. + */ + IMPORT_C TInt LogDllLoaded( const TDesC8& aDllName, TUint32 aStartAddress, + TUint32 aEndAddress ); + + /** + * Asks the server to log that a new DLL has been unloaded. Note, the method + * LogProcessStarted() has to be previously called. Otherwise a STSEClient: 3 + * panic is raised. A KERN-EXEC: 0 panic is raised if the client is not connected + * to the server. If the method is called with illegal parameter values, a + * STSEClient: 2 panic is raised. + * @param aDllName The name of the DLL to be unloaded. The length of this + * descriptor must not be greater than KMaxLibraryName, otherwise the method + * raises a STSEClient: 2 panic. + * @param aStartAddress The start address of the DLL to be unloaded. + * @param aEndAddress The end address of the DLL to be unloaded. + * @return KErrNone, if successful; otherwise one of the other + * system-wide error codes. + */ + IMPORT_C TInt LogDllUnloaded( const TDesC8& aDllName, TUint32 aStartAddress, + TUint32 aEndAddress ); + + /** + * Informs the server that a memory allocation has occured at the specified + * address. Sends also the current call stack to the server. Note, the method + * LogProcessStarted() has to be previously called. Otherwise a STSEClient: 3 + * panic is raised. A KERN-EXEC: 0 panic is raised if the client is not connected + * to the server. + * @param aMemAddress The memory location where memory has been allocated. + * @param aCallstack An array including the current call stack. + * @param aSize The size of the newly allocated memory chunk. + * @return KErrNone, if successful; otherwise one of the other + * system-wide error codes. + */ + IMPORT_C TInt LogMemoryAllocated( TUint32 aMemAddress, + TFixedArray& aCallstack, + TInt aSize ); + + /** + * Informs the server that memory was released at the specified address. Note, + * the method LogProcessStarted() has to be previously called. Otherwise a + * STSEClient: 3 panic is raised. A KERN-EXEC: 0 panic is raised if the client is + * not connected to the server. + * @param aMemAddress The memory location where memory has been deallocated. + * @param aFreeCallstack An array including the current call stack. + * @return KErrNone, if successful; otherwise one of the other + * system-wide error codes. + */ + IMPORT_C TInt LogMemoryFreed( TUint32 aMemAddress, + TFixedArray& aFreeCallstack ); + + /** + * Tells the server that the process under test has been ended. Prints information + * related to process ending, such as possibly occured memory leaks (when file + * logging mode used), and possibly occured handle leaks. Note, the method + * LogProcessStarted() has to be previously called. Otherwise a STSEClient: + * 3 panic is raised. A call to this method also closes the file opened for + * the current process. So, no further logging is possible without a new call + * to the method LogProcessStarted(). A KERN-EXEC: 0 panic is raised if the client + * is not connected to the server. + * @param aProcessId The ID number of the process ended. + * @param aHandleLeaks Amount of handle leaks. + * @return KErrNone, if successful; otherwise one of the other + * system-wide error codes. + */ + IMPORT_C TInt LogProcessEnded( TUint aProcessId, + TUint aHandleLeaks ); + + /** + * Gives the lowest version number of the server needed for this client. + * @return The lowest version of the server needed for this client. + */ + IMPORT_C TVersion Version() const; + + /** + * Checks if the current process has allocated, but not freed, the given memory + * address. Note, the method LogProcessStarted() has to be previously called. + * Otherwise a STSEClient: 3 panic is raised. A KERN-EXEC: 0 panic is raised if + * the client is not connected to the server. + * @param aMemAddress The memory location to check. + * @return When the system is logging into a file: the index of a found + * memory address or KErrNotFound, if a matching memory address cannot + * be found. When the system is not logging into a file: always KErrNone. + */ + IMPORT_C TInt CheckMemoryAddress( TUint32 aMemAddress ) const; + + /** + * Gets all the processes with currently open logging sessions. + * @param aProcesses A reference to a process array to be filled by the server. + * @return KErrNone, if successful; otherwise one of the other + * system wide error codes. + */ + IMPORT_C TInt GetProcessesL( RArray& aProcesses ); + + /** + * Gets all the DLLs loaded by the given process. + * @param aProcessId The ID of the process whose DLLs will be fetched. + * @param aDlls An array that after this function call includes names of + * the given process's dlls + * @return KErrNone, if successful; KErrNotFound, if the requested process was + * not found; otherwise one of the other system wide error codes. + */ + IMPORT_C TInt GetLoadedDllsL( TUint aProcessId, + RArray< TBuf8 >& aDlls ); + + /** + * Gets the logging mode of the given process. + * @param aProcessId The ID of the process whose logging mode is being asked. + * @param aLoggingMode An enumeration telling the logging mode after a call + * to this function. + * @return KErrNone, if successful; KErrNotFound, if the requested process was + * not found; otherwise one of the other system wide error codes. + */ + IMPORT_C TInt GetLoggingModeL( TUint aProcessId, TATLogOption& aLoggingMode ); + + /** + * Starts a sub test for the given process. + * @param aProcessId The ID of the process for which to start a sub test. + * @param aSubtestId The name identifying this particular sub test. The length + * of this descriptor must not be greater than KATMaxSubtestIdLength, or + * otherwise the method raises a STSEClient: 2 panic. + * @param aHandleCount The current handle count of a particular process. + * @return KErrNone, if successful; KErrNotFound, if the requested process was not + * found; KErrNotSupported, if the requested process does not have a logging + * session ongoing or its logging mode is not EATLogToTrace; Otherwise one of the + * other system wide error codes. + */ + IMPORT_C TInt StartSubTest( TUint aProcessId, const TDesC8& aSubtestId, TInt aHandleCount = 0 ); + + /** + * Stops a sub test for the given process. + * @param aProcessId The ID of the process for which to stop a sub test. + * @param aSubtestId The name identifying this particular sub test. The length + * of this descriptor must not be greater than KATMaxSubtestIdLength, or + * otherwise the method raises a STSEClient: 2 panic. + * @param aHandleCount The current handle count of a particular process. + * @return KErrNone, if successful; KErrNotFound, if the requested process was not + * found; KErrNotSupported, if the requested process does not have a logging + * session ongoing or its logging mode is not EATLogToTrace; Otherwise one of the + * other system wide error codes. + */ + IMPORT_C TInt StopSubTest( TUint aProcessId, const TDesC8& aSubtestId, TInt aHandleCount = 0 ); + + /** + * Gets the number and total size of the memory chunks currently allocated by the + * requested process. + * @param aProcessId The ID of the process whose information is requested. + * @param aNumber On return contains the number of memory chunks currenlty + * allocated by the requested process. + * @param aSize On return contains the amount of memory currently allocated + * by the requested process. + * @return KErrNone, if successful; KErrNotFound, if the requested process was not + * found; Otherwise one of the other system wide error codes. + */ + IMPORT_C TInt GetCurrentAllocsL( TUint aProcessId, TUint32& aNumber, TUint32& aSize ); + + /** + * Gets the maximum number and total size of the memory chunks allocated by the + * requested process. + * @param aProcessId The ID of the process whose information is requested. + * @param aNumber On return contains the maximum number of memory chunks + * allocated by the requested process during the test run. + * @param aSize On return contains the maximum amount of memory allocated + * by the requested process during the test run. + * @return KErrNone, if successful; KErrNotFound, if the requested process was not + * found; Otherwise one of the other system wide error codes. + */ + IMPORT_C TInt GetMaxAllocsL( TUint aProcessId, TUint32& aNumber, TUint32& aSize ); + + /** + * Starts a sub test for the calling process. + * @param aSubtestId The name identifying this particular sub test. The length + * of this descriptor must not be greater than KATMaxSubtestIdLength, or + * otherwise the method raises a STSEClient: 2 panic. + * @return KErrNone, if successful; KErrNotSupported, if the calling process + * does not have a logging session ongoing or its logging mode is not + * EATLogToTrace; Otherwise one of the other system wide error codes. + */ + IMPORT_C TInt StartSubTest( const TDesC8& aSubtestId ); + + /** + * Stops a sub test for the calling process + * @param aSubtestId The name identifying this particular sub test. The length + * of this descriptor must not be greater than KATMaxSubtestIdLength, or + * otherwise the method raises a STSEClient: 2 panic. + * @return KErrNone, if successful; KErrNotSupported, if the calling process + * does not have a logging session ongoing or its logging mode is not + * EATLogToTrace; Otherwise one of the other system wide error codes. + */ + IMPORT_C TInt StopSubTest( const TDesC8& aSubtestId ); + + /** + * Cancels logging for the requested process. After logging of a given process + * has been cancelled, the session associated with that process will not be + * usable anymore. If a process wants to start logging again, it needs to close + * the handle and open it again in order to create a new session. Until then, most + * of the client's methods will return KErrCancel. + * @param aProcessId The process ID of the process whose logging is requested to + * be cancelled. + * @return KErrNone, if successful; KErrNotFound, if the requested process was + * not found; otherwise one of the other system wide error codes. + */ + IMPORT_C TInt CancelLogging( TUint aProcessId ); + + /** + * Gets the number and total size of the memory chunks currently allocated by the + * requested process. + * @param aProcessId The ID of the process whose information is requested. + * @param aIsUdeb On return contains an value greater than KErrNone if + * mode is UDEB. Else the mode is UREL + * @return KErrNone, if successful; KErrNotFound, if the requested process was not + * found; Otherwise one of the other system wide error codes. + */ + IMPORT_C TInt GetUdebL( TUint aProcessId, TUint32& aIsUdeb ); + + /** + * Gets the number and total size of the memory chunks currently allocated by the + * requested process. + * @param aProcessId The ID of the process whose information is requested. + * @param aFileName On return contains logging filename for the process. + * @return KErrNone, if successful; KErrNotFound, if the requested process was not + * found; Otherwise one of the other system wide error codes. + */ + IMPORT_C TInt GetLoggingFileL( TUint aProcessId, TDes8& aFileName ); + + /** + * Check a memory allocation (memory address) from an internal array. + * @param aMemAddress The memory address to be check + * @return KErrNone, if memory address found in array; + * KErrNotFound, if the requested memory address was not found. + */ + IMPORT_C TInt IsMemoryAdded( TUint32 aMemAddress ); + + protected: // New functions + + /** + * Creates a new process for the server, if it does not already exist. + * @return KErrNone, if successful; otherwise one of the other + * system-wide error codes. + */ + TInt CreateProcess(); + + private: // Internal functions + + /** + * Creates two buffers: one for storing call stack memory addresses and one for + * handle leaks. Internally used by this class. May leave, if there is + * insufficient memory. + */ + void ConstructBuffersL(); + + private: // Data + + /** A pointer to a buffer of call stack's memory addresses */ + CBufFlat* iStackBuf; + }; + +#endif // ATSTORAGESERVERCLNT_H + + +// End of File diff -r d27dfa8884ad -r da2cedce4920 analyzetool/storageserver/client/src/atstorageserverclnt.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/storageserver/client/src/atstorageserverclnt.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,930 @@ +/* +* 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 client side handle class RATStorageServer +* +*/ + + + +// INCLUDE FILES +#include "atstorageserverclnt.h" +#include "atstorageserver.h" +#include "atlog.h" +#include "atstorageservercommon.h" + + +// CONSTANTS + +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// RATStorageServer::RATStorageServer +// C++ default constructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C RATStorageServer::RATStorageServer() : + RSessionBase(), iStackBuf( NULL ) + { + LOGSTR1( "STSE RATStorageServer::RATStorageServer()" ); + } + +// ----------------------------------------------------------------------------- +// RATStorageServer::Connect +// A function for connecting to the server +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RATStorageServer::Connect() + { + LOGSTR1( "STSE TInt RATStorageServer::Connect()" ); + + TInt errorCode( KErrNone ); + errorCode = CreateProcess(); + + // If process's creation failed, return the error code + if ( errorCode != KErrNone ) + { + return errorCode; + } + + // Otherwise create a new session + errorCode = CreateSession( KStorageServerName, Version() ); + + // If creation of a new session failed, return the error code + if ( errorCode != KErrNone ) + { + return errorCode; + } + + // Construct a buffer for call stack's memory addresses. If the function leaves, + // the leave code is put in "errorCode". + TRAP( errorCode, ConstructBuffersL() ); + + return errorCode; + } + +// ----------------------------------------------------------------------------- +// RATStorageServer::Close +// Destroys all memory reserved by this class, and calls RSessionBase::Close() +// ----------------------------------------------------------------------------- +// +EXPORT_C void RATStorageServer::Close() + { + LOGSTR1( "STSE void RATStorageServer::Close()" ); + + // Delete iStackBuf + delete iStackBuf; + iStackBuf = NULL; + + // Call the base class' Close() + RSessionBase::Close(); + } + +// ----------------------------------------------------------------------------- +// RATStorageServer::LogProcessStarted +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RATStorageServer::LogProcessStarted( const TDesC& aFileName, + const TDesC8& aProcessName, + TUint aProcessId, + TUint32 aLogOption, TUint32 aIsDebug ) + { + LOGSTR1( "STSE TInt RATStorageServer::LogProcessStarted()" ); + + // Panic always if aFileName or aProcessName are longer than allowed. + __ASSERT_ALWAYS( aFileName.Length() <= KMaxFileName && + aProcessName.Length() <= KMaxProcessName, + StorageServerPanic( KCategoryClient, EAToolBadArgument ) ); + + // Panic (in debug builds) if aProcessId is KNullProcessId + __ASSERT_DEBUG( aProcessId != KNullProcessId, + StorageServerPanic( KCategoryClient, EAToolBadArgument ) ); + + // This information is optional -> ignoring error + // Must be before EProcessStarted in order to append udeb/urel + // information to LogProcessStarted + TIpcArgs ipcArgs2( aIsDebug ); + SendReceive( CATStorageServer::EProcessUdeb, ipcArgs2 ); + + TIpcArgs ipcArgs( &aFileName, &aProcessName, aProcessId, aLogOption ); + TInt error( 0 ); + + error = SendReceive( CATStorageServer::EProcessStarted, ipcArgs ); + + // Return, if error is not KErrNone. + if ( error != KErrNone ) + { + return error; + } + + return KErrNone; + } + +// ----------------------------------------------------------------------------- +// RATStorageServer::LogDllLoaded +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RATStorageServer::LogDllLoaded( const TDesC8& aDllName, + TUint32 aStartAddress, + TUint32 aEndAddress ) + { + LOGSTR1( "STSE TInt RATStorageServer::LogDllLoaded()" ); + + // Panic always if aDllName is longer than allowed. + __ASSERT_ALWAYS( aDllName.Length() <= KMaxLibraryName, + StorageServerPanic( KCategoryClient, EAToolBadArgument ) ); + + // Panic (in debug builds) if aStartAddress is greater than aEndAddress + __ASSERT_DEBUG( aStartAddress <= aEndAddress, + StorageServerPanic( KCategoryClient, EAToolBadArgument ) ); + + TIpcArgs ipcArgs( &aDllName, aStartAddress, aEndAddress ); + + return SendReceive( CATStorageServer::EDllLoaded, ipcArgs ); + } + +// ----------------------------------------------------------------------------- +// RATStorageServer::LogDllUnloaded +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RATStorageServer::LogDllUnloaded( const TDesC8& aDllName, + TUint32 aStartAddress, + TUint32 aEndAddress ) + { + LOGSTR1( "STSE TInt RATStorageServer::LogDllUnloaded()" ); + + // Panic always if aDllName is longer than allowed. + __ASSERT_ALWAYS( aDllName.Length() <= KMaxLibraryName, + StorageServerPanic( KCategoryClient, EAToolBadArgument ) ); + + // Panic (in debug builds) if aStartAddress is greater than aEndAddress + __ASSERT_DEBUG( aStartAddress <= aEndAddress, + StorageServerPanic( KCategoryClient, EAToolBadArgument ) ); + + TIpcArgs ipcArgs( &aDllName, aStartAddress, aEndAddress ); + + return SendReceive( CATStorageServer::EDllUnloaded, ipcArgs ); + } + +// ----------------------------------------------------------------------------- +// RATStorageServer::LogMemoryAllocated +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RATStorageServer::LogMemoryAllocated( TUint32 aMemAddress, + TFixedArray& aCallstack, + TInt aSize ) + { + LOGSTR1( "STSE TInt RATStorageServer::LogMemoryAllocated()" ); + + TInt count=0; + // The number of memory addresses in aCallstack + for ( TInt i = 0; i < KATMaxCallstackLength; i++ ) + { + if( aCallstack[i] == 0 ) + { + break; + } + count++; + } + + LOGSTR2( "STSE The number of memory addresses in the current call stack: %d", count ); + + // The maximum number of call stack's memory addresses this server can handle + // is KMaxCallstackLength + if ( count > KATMaxCallstackLength ) + { + count = KATMaxCallstackLength; + } + + // Panic (in debug builds) if the parameters are faulty + __ASSERT_DEBUG( aMemAddress != 0 && count >= 0 && aSize >= 0, + StorageServerPanic( KCategoryClient, EAToolBadArgument ) ); + + // Buffer position + TInt pos = 0; + TUint32 callStackAddr; + + // Write the number of memory addresses of aCallstack (one word) into + // the beginning of the call stack buffer + iStackBuf->Write( pos, &count, KWordSize ); + + // Increase the position by one word + pos += KWordSize; + + // Write all the memory addresses of aCallStack into the buffer + for ( TInt i = 0; i < count; i++ ) + { + callStackAddr = aCallstack[i]; + + // Write the current memory address (the length of an address is one word) + iStackBuf->Write( pos, &callStackAddr, KWordSize ); + + // Move the pos variable one word (4 bytes) onwards. + pos += KWordSize; + } + + TPtr8 bufPtr( iStackBuf->Ptr(0) ); + + TIpcArgs ipcArgs( aMemAddress, &bufPtr, aSize ); + + return SendReceive( CATStorageServer::EMemoryAllocated, ipcArgs ); + } + +// ----------------------------------------------------------------------------- +// RATStorageServer::LogMemoryFreed +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RATStorageServer::LogMemoryFreed( TUint32 aMemAddress, + TFixedArray& aFreeCallstack ) + { + LOGSTR1( "STSE TInt RATStorageServer::LogMemoryFreed()" ); + + TInt count=0; + // The number of memory addresses in aFreeCallstack + for ( TInt i = 0; i < KATMaxCallstackLength; i++ ) + { + if( aFreeCallstack[i] == 0 ) + { + break; + } + count++; + } + LOGSTR3( "STSE > aFreeCallstack.Count() ( %i ), address( %x )", + count, aMemAddress ); + + // The maximum number of call stack's memory addresses this server can handle + // is KMaxCallstackLength + if ( count > KATMaxFreeCallstackLength ) + { + count = KATMaxFreeCallstackLength; + } + + // Buffer position + TInt pos = 0; + TUint32 callStackAddr; + + // Write the number of memory addresses of aFreeCallstack (one word) into + // the beginning of the call stack buffer + iStackBuf->Write( pos, &count, KWordSize ); + + // Increase the position by one word + pos += KWordSize; + + // Write all the memory addresses of aFreeCallstack into the buffer + for ( TInt i = 0; i < count; i++ ) + { + callStackAddr = aFreeCallstack[i]; + + // Write the current memory address (the length of an address is one word) + iStackBuf->Write( pos, &callStackAddr, KWordSize ); + + // Move the pos variable one word (4 bytes) onwards. + pos += KWordSize; + } + + TPtr8 bufPtr( iStackBuf->Ptr( 0 ) ); + TIpcArgs ipcArgs( aMemAddress, &bufPtr ); + + return SendReceive( CATStorageServer::EMemoryFreed, ipcArgs ); + } + +// ----------------------------------------------------------------------------- +// RATStorageServer::LogProcessEnded +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RATStorageServer::LogProcessEnded( TUint aProcessId, + TUint aHandleLeaks ) + { + LOGSTR1( "STSE TInt RATStorageServer::LogProcessEnded()" ); + + // Panic (in debug builds) if the parameters are faulty + __ASSERT_DEBUG( aProcessId != KNullProcessId, + StorageServerPanic( KCategoryClient, EAToolBadArgument ) ); + + TIpcArgs ipcArgs( aProcessId, aHandleLeaks ); + + return SendReceive( CATStorageServer::EProcessEnded, ipcArgs ); + } + +//----------------------------------------------------------------------------- +// RATStorageServer::Version() +// Returns the version number. +//----------------------------------------------------------------------------- +// +EXPORT_C TVersion RATStorageServer::Version() const + { + LOGSTR1( "STSE TInt RATStorageServer::Version()" ); + + return TVersion(KLowestVersionNumberMaj, KLowestVersionNumberMin, + KLowestVersionNumberBld); + } + +// ----------------------------------------------------------------------------- +// RATStorageServer::CheckMemoryAddress +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RATStorageServer::CheckMemoryAddress( TUint32 aMemAddress ) const + { + LOGSTR1( "STSE TInt RATStorageServer::CheckMemoryAddress()" ); + + // Panic (in debug builds) if the parameters are faulty + __ASSERT_DEBUG( aMemAddress != 0, + StorageServerPanic( KCategoryClient, EAToolBadArgument ) ); + + TIpcArgs ipcArgs( aMemAddress ); + + return SendReceive( CATStorageServer::EMemoryCheck, ipcArgs ); + } + +// ----------------------------------------------------------------------------- +// RATStorageServer::GetProcessesL +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RATStorageServer::GetProcessesL( RArray& aProcesses ) + { + LOGSTR1( "STSE TInt RATStorageServer::GetProcessesL()" ); + + TInt error( KErrNone ); + TInt sizeOfProcessInfo = sizeof( TATProcessInfo ); + + // Reset the sent array + aProcesses.Reset(); + + // Calculate the length of the buffer to be constructed for processes. + // One word will be reserved for the length of the array. + TInt bufferLength = KWordSize + KATMaxProcesses * sizeOfProcessInfo; + + CBufFlat* processBuf; + // Construct processBuf and expand it before the beginning (index 0) + processBuf = CBufFlat::NewL( bufferLength ); + CleanupStack::PushL( processBuf ); + processBuf->ExpandL( 0, bufferLength ); + + TPtr8 bufPtr( processBuf->Ptr(0) ); + + // Send the buffer to the server, which will fill it. + TIpcArgs ipcArgs( &bufPtr ); + error = SendReceive( CATStorageServer::EGetProcesses, ipcArgs ); + // Return with the error code if the operation failed + if ( error != KErrNone ) + { + CleanupStack::PopAndDestroy( processBuf ); + return error; + } + + // A variable for the number of TATProcessInfo objects + TInt count( 0 ); + // A variable for the position + TInt pos( 0 ); + + // Read the value for count + processBuf->Read( pos, &count, KWordSize ); + + // Return if we got an illegal value for count + if ( count < 0 || count > KATMaxProcesses ) + { + CleanupStack::PopAndDestroy( processBuf ); + return KErrGeneral; + } + + // Move the position one word onwards. + pos += KWordSize; + + TATProcessInfo processInfo; + + // Go through all TATProcessInfo objects sent to the server + for ( TInt j = 0; j < count; j++ ) + { + // Read one of the TATProcessInfo objects stored in the buffer. + processBuf->Read( pos, &processInfo, sizeOfProcessInfo ); + + // Append this processInfo to the array + error = aProcesses.Append( processInfo ); + + if ( error != KErrNone ) + { + CleanupStack::PopAndDestroy( processBuf ); + return error; + } + + // Move the pos variable one word onwards. + pos += sizeOfProcessInfo; + } + + CleanupStack::PopAndDestroy( processBuf ); + return error; + } + +// ----------------------------------------------------------------------------- +// RATStorageServer::GetLoadedDllsL +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RATStorageServer::GetLoadedDllsL( TUint aProcessId, + RArray< TBuf8 >& aDlls ) + { + LOGSTR1( "STSE TInt RATStorageServer::GetLoadedDllsL()" ); + + // Panic (in debug builds) if aProcessId is faulty + __ASSERT_DEBUG( aProcessId != KNullProcessId, + StorageServerPanic( KCategoryClient, EAToolBadArgument ) ); + + TInt error( KErrNone ); + + // Size of a DLL descriptor + TInt sizeOfDllDesc = sizeof( TBuf8 ); + + // Reset the sent array + aDlls.Reset(); + + // Calculate the length of the buffer to be constructed for DLL names. + // One word will be reserved for the length of the array. + TInt bufferLength = KWordSize + KATMaxDlls * sizeOfDllDesc; + + CBufFlat* dllBuf; + // Construct dllBuf and expand it before the beginning (index 0) + dllBuf = CBufFlat::NewL( bufferLength ); + CleanupStack::PushL( dllBuf ); + dllBuf->ExpandL( 0, bufferLength ); + + TPtr8 bufPtr( dllBuf->Ptr(0) ); + + // Call the server with the given arguments + TIpcArgs ipcArgs( aProcessId, &bufPtr ); + error = SendReceive( CATStorageServer::EGetDlls, ipcArgs ); + + // Return, if error is not KErrNone. + if ( error != KErrNone ) + { + CleanupStack::PopAndDestroy( dllBuf ); + return error; + } + + // A variable for the number of objects in the buffer + TInt count( 0 ); + + // A variable for the position + TInt pos( 0 ); + + // Read the value for count + dllBuf->Read( pos, &count, KWordSize ); + + // Return if we got an illegal value for count + if ( count < 0 || count > KATMaxDlls ) + { + CleanupStack::PopAndDestroy( dllBuf ); + return KErrGeneral; + } + + // Move the position one word onwards. + pos += KWordSize; + + TBuf8 dllName; + + // Go through all DLL names objects sent to the server + for ( TInt j = 0; j < count; j++ ) + { + // Read one of the DLL names stored in the buffer. + dllBuf->Read( pos, &dllName, sizeOfDllDesc ); + + // Append this DLL name to the array + error = aDlls.Append( dllName ); + + if ( error != KErrNone ) + { + return error; + } + + // Move the pos variable one word onwards. + pos += sizeOfDllDesc; + } + + CleanupStack::PopAndDestroy( dllBuf ); + return error; + } + +// ----------------------------------------------------------------------------- +// RATStorageServer::GetLoggingModeL +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RATStorageServer::GetLoggingModeL( TUint aProcessId, + TATLogOption& aLoggingMode ) + { + LOGSTR1( "STSE TInt RATStorageServer::GetLoggingModeL()" ); + + // Panic (in debug builds) if aProcessId is illegal + __ASSERT_DEBUG( aProcessId != KNullProcessId, + StorageServerPanic( KCategoryClient, EAToolBadArgument ) ); + + TInt error(0); + + // The length of the buffer to be constructed for logging mode + TInt bufferLength = KWordSize; + + CBufFlat* loggingModeBuf; + // Construct allocInfoBuf and expand it before the beginning (index 0) + loggingModeBuf = CBufFlat::NewL( bufferLength ); + CleanupStack::PushL( loggingModeBuf ); + loggingModeBuf->ExpandL( 0, bufferLength ); + + TPtr8 bufPtr( loggingModeBuf->Ptr(0) ); + + // Call the server + TIpcArgs ipcArgs( aProcessId, &bufPtr ); + error = SendReceive( CATStorageServer::EGetLoggingMode, ipcArgs ); + + // Return if an error occured. + if ( error ) + { + CleanupStack::PopAndDestroy( loggingModeBuf ); + return error; + } + + // A variable for the position + TInt pos( 0 ); + + // Read the value for aNumber + loggingModeBuf->Read( pos, &aLoggingMode, KWordSize ); + + CleanupStack::PopAndDestroy( loggingModeBuf ); + + return KErrNone; + } + +// ----------------------------------------------------------------------------- +// RATStorageServer::StartSubTest +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RATStorageServer::StartSubTest( TUint aProcessId, + const TDesC8& aSubtestId, TInt aHandleCount ) + { + LOGSTR1( "STSE TInt RATStorageServer::StartSubTest()" ); + + // Panic if the parameters are faulty + __ASSERT_ALWAYS( aSubtestId.Length() <= KATMaxSubtestIdLength, + StorageServerPanic( KCategoryClient, EAToolBadArgument ) ); + + // Panic (in debug builds) if the parameters are faulty + __ASSERT_DEBUG( aProcessId != KNullProcessId, + StorageServerPanic( KCategoryClient, EAToolBadArgument ) ); + + TIpcArgs ipcArgs( aProcessId, &aSubtestId, aHandleCount ); + + return SendReceive( CATStorageServer::ESubtestStart, ipcArgs ); + } + +// ----------------------------------------------------------------------------- +// RATStorageServer::StopSubTest +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RATStorageServer::StopSubTest( TUint aProcessId, + const TDesC8& aSubtestId, TInt aHandleCount ) + { + LOGSTR1( "STSE TInt RATStorageServer::StopSubTest()" ); + + // Panic if the parameters are faulty + __ASSERT_ALWAYS( aSubtestId.Length() <= KATMaxSubtestIdLength, + StorageServerPanic( KCategoryClient, EAToolBadArgument ) ); + + // Panic (in debug builds) if the parameters are faulty + __ASSERT_DEBUG( aProcessId != KNullProcessId, + StorageServerPanic( KCategoryClient, EAToolBadArgument ) ); + + TIpcArgs ipcArgs( aProcessId, &aSubtestId, aHandleCount ); + + return SendReceive( CATStorageServer::ESubtestStop, ipcArgs ); + } + +// ----------------------------------------------------------------------------- +// RATStorageServer::GetCurrentAllocsL +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RATStorageServer::GetCurrentAllocsL( TUint aProcessId, + TUint32& aNumber, + TUint32& aSize ) + { + LOGSTR1( "STSE TInt RATStorageServer::GetCurrentAllocsL()" ); + + // Panic (in debug builds) if aProcessId is illegal + __ASSERT_DEBUG( aProcessId != KNullProcessId, + StorageServerPanic( KCategoryClient, EAToolBadArgument ) ); + + TInt error(0); + + // The length of the buffer to be constructed for allocation number and size + TInt bufferLength = KWordSize + KWordSize; + + CBufFlat* allocInfoBuf; + // Construct allocInfoBuf and expand it before the beginning (index 0) + allocInfoBuf = CBufFlat::NewL( bufferLength ); + CleanupStack::PushL( allocInfoBuf ); + allocInfoBuf->ExpandL( 0, bufferLength ); + + TPtr8 bufPtr( allocInfoBuf->Ptr(0) ); + + // Call the server + TIpcArgs ipcArgs( aProcessId, &bufPtr ); + error = SendReceive( CATStorageServer::EGetCurrentAllocs, ipcArgs ); + + // Return if error is not KErrNone. + if ( error != KErrNone ) + { + CleanupStack::PopAndDestroy( allocInfoBuf ); + return error; + } + + // A variable for the position + TInt pos( 0 ); + + // Read the value for aNumber + allocInfoBuf->Read( pos, &aNumber, KWordSize ); + + pos += KWordSize; + + // Read the value for aSize + allocInfoBuf->Read( pos, &aSize, KWordSize ); + + CleanupStack::PopAndDestroy( allocInfoBuf ); + + return KErrNone; + } + +// ----------------------------------------------------------------------------- +// RATStorageServer::GetMaxAllocsL +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RATStorageServer::GetMaxAllocsL( TUint aProcessId, + TUint32& aNumber, + TUint32& aSize ) + { + LOGSTR1( "STSE TInt RATStorageServer::GetMaxAllocsL()" ); + + // Panic (in debug builds) if aProcessId is illegal + __ASSERT_DEBUG( aProcessId != KNullProcessId, + StorageServerPanic( KCategoryClient, EAToolBadArgument ) ); + + TInt error(0); + + // The length of the buffer to be constructed for allocation number and size + TInt bufferLength = KWordSize + KWordSize; + + CBufFlat* allocInfoBuf; + // Construct allocInfoBuf and expand it before the beginning (index 0) + allocInfoBuf = CBufFlat::NewL( bufferLength ); + CleanupStack::PushL( allocInfoBuf ); + allocInfoBuf->ExpandL( 0, bufferLength ); + + TPtr8 bufPtr( allocInfoBuf->Ptr(0) ); + + // Call the server + TIpcArgs ipcArgs( aProcessId, &bufPtr ); + error = SendReceive( CATStorageServer::EGetMaxAllocs, ipcArgs ); + + // Return, if error is not KErrNone. + if ( error != KErrNone ) + { + CleanupStack::PopAndDestroy( allocInfoBuf ); + return error; + } + + // A variable for the position + TInt pos( 0 ); + + // Read the value for aNumber + allocInfoBuf->Read( pos, &aNumber, KWordSize ); + + pos += KWordSize; + + // Read the value for aSize + allocInfoBuf->Read( pos, &aSize, KWordSize ); + + CleanupStack::PopAndDestroy( allocInfoBuf ); + + return KErrNone; + } + +// ----------------------------------------------------------------------------- +// RATStorageServer::StartSubTest +// An overloaded version without a PID parameter +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RATStorageServer::StartSubTest( const TDesC8& aSubtestId ) + { + LOGSTR1( "STSE TInt RATStorageServer::StartSubTest()" ); + + // Panic if the parameters are faulty + __ASSERT_ALWAYS( aSubtestId.Length() <= KATMaxSubtestIdLength, + StorageServerPanic( KCategoryClient, EAToolBadArgument ) ); + + TIpcArgs ipcArgs( &aSubtestId ); + + return SendReceive( CATStorageServer::ESubtestStart2, ipcArgs ); + } + +// ----------------------------------------------------------------------------- +// RATStorageServer::StopSubTest +// An overloaded version without a PID parameter +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RATStorageServer::StopSubTest( const TDesC8& aSubtestId ) + { + LOGSTR1( "STSE TInt RATStorageServer::StopSubTest()" ); + + // Panic if the parameters are faulty + __ASSERT_ALWAYS( aSubtestId.Length() <= KATMaxSubtestIdLength, + StorageServerPanic( KCategoryClient, EAToolBadArgument ) ); + + TIpcArgs ipcArgs( &aSubtestId ); + + return SendReceive( CATStorageServer::ESubtestStop2, ipcArgs ); + } + +// ----------------------------------------------------------------------------- +// RATStorageServer::CancelLogging +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RATStorageServer::CancelLogging( TUint aProcessId ) + { + LOGSTR1( "STSE TInt RATStorageServer::CancelLogging()" ); + + // Panic (in debug builds) if aProcessId is illegal + __ASSERT_DEBUG( aProcessId != KNullProcessId, + StorageServerPanic( KCategoryClient, EAToolBadArgument ) ); + + TIpcArgs ipcArgs( aProcessId ); + + return SendReceive( CATStorageServer::ECancelLogging, ipcArgs ); + } + +// ----------------------------------------------------------------------------- +// RATStorageServer::CreateProcess +// Checks if the server already exists. If it doesn't, creates a new process +// for it. +// ----------------------------------------------------------------------------- +// +TInt RATStorageServer::CreateProcess() + { + LOGSTR1( "STSE TInt RATStorageServer::CreateProcess()" ); + + TInt errorCode( KErrNone ); + + // Check if the server already exists + TFindServer findServer( KStorageServerName ); + TFullName fullName; + + errorCode = findServer.Next( fullName ); + + // Return KErrNone if the server is already running + if ( errorCode == KErrNone ) + { + return KErrNone; + } + + // Otherwise initiate starting the server by creating first a new process for it. + // The second argument of the Create() method call is an empty descriptor, because + // we don't need to pass any data to the thread function of the new process's main + // thread. + RProcess process; + errorCode = process.Create( KStorageServerFile, KNullDesC ); + + // Return the error code if the creation of the process failed + if ( errorCode != KErrNone ) + { + return errorCode; + } + + TRequestStatus status; + process.Rendezvous( status ); + + // If the status is not KRequestPending, abort the project creation + // and return KErrGeneral + if ( status != KRequestPending ) + { + process.RendezvousCancel( status ); + process.Kill( KErrGeneral ); + process.Close(); + return KErrGeneral; + } + + // Otherwise make the first thread of the new process eligible for execution + process.Resume(); + + // Wait for a signal from the server + User::WaitForRequest( status ); + + // Close the process handle + process.Close(); + + // Return the error code + return status.Int(); + } + +// ----------------------------------------------------------------------------- +// RATStorageServer::ConstructBuffersL +// Allocates buffers from heap. Called when connecting to the server +// ----------------------------------------------------------------------------- +// +void RATStorageServer::ConstructBuffersL() + { + LOGSTR1( "STSE void RATStorageServer::ConstructBuffersL()" ); + + // Calculate the length of the buffer to be constructed for call stack. + // One word will be reserved for the length of the array + TInt bufferLength = ( (1 + KATMaxCallstackLength) * KWordSize ); + + // Construct iStackBuf and expand it before the beginning (index 0) + iStackBuf = CBufFlat::NewL( bufferLength ); + iStackBuf->ExpandL( 0, bufferLength ); + } + +// ----------------------------------------------------------------------------- +// RATStorageServer::GetLoggingFileL +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RATStorageServer::GetLoggingFileL( TUint aProcessId, + TDes8& aFileName ) + { + LOGSTR1( "STSE TInt RATStorageServer::GetLoggingFileL()" ); + + // Panic (in debug builds) if aProcessId is illegal + __ASSERT_DEBUG( aProcessId != KNullProcessId, + StorageServerPanic( KCategoryClient, EAToolBadArgument ) ); + + TInt error(0); + + TBuf8 fileBuf; + // Call the server + TIpcArgs ipcArgs( aProcessId, &fileBuf ); + error = SendReceive( CATStorageServer::EGetLoggingFile, ipcArgs ); + + // Return, if an error occured. + if ( error ) + { + return error; + } + + aFileName.Copy( fileBuf ); + return KErrNone; + } + +// ----------------------------------------------------------------------------- +// RATStorageServer::GetUdebL +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RATStorageServer::GetUdebL( TUint aProcessId, TUint32& aIsUdeb ) + { + LOGSTR1( "STSE TInt RATStorageServer::GetUdebL()" ); + + // Panic (in debug builds) if aProcessId is illegal + __ASSERT_DEBUG( aProcessId != KNullProcessId, + StorageServerPanic( KCategoryClient, EAToolBadArgument ) ); + + TInt error(0); + TBuf8 isUdeb; + _LIT8( KUdeb, "UDEB" ); + // Call the server + TIpcArgs ipcArgs( aProcessId, &isUdeb ); + error = SendReceive( CATStorageServer::EGetUdeb, ipcArgs ); + + // Return, if an error occured. + if ( error != KErrNone ) + { + return error; + } + + if ( isUdeb.Compare( KUdeb() ) == 0 ) + { + LOGSTR1( "STSE TInt RATStorageServer::GetUdebL() - Is UDEB" ); + aIsUdeb = 1; + } + else + { + LOGSTR1( "STSE TInt RATStorageServer::GetUdebL() - Is UREL" ); + aIsUdeb = 0; + } + + return KErrNone; + } + +// ----------------------------------------------------------------------------- +// RATStorageServer::IsMemoryAdded +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt RATStorageServer::IsMemoryAdded( TUint32 aMemAddress ) + { + LOGSTR1( "STSE TInt RATStorageServer::IsMemoryAdded()" ); + + TIpcArgs ipcArgs( aMemAddress ); + return SendReceive( CATStorageServer::EIsMemoryAdded, ipcArgs ); + } + +// End of File diff -r d27dfa8884ad -r da2cedce4920 analyzetool/storageserver/group/bld.inf --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/storageserver/group/bld.inf Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,31 @@ +/* +* 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: +* +*/ + +#include + +PRJ_PLATFORMS +ARMV5 WINSCW + +PRJ_EXPORTS +../client/inc/atstorageserverclnt.h OS_LAYER_PLATFORM_EXPORT_PATH(analyzetool/atstorageserverclnt.h) + +PRJ_MMPFILES +../server/group/atoolstorageserver.mmp +../client/group/atoolstorageserverclnt.mmp + +PRJ_TESTMMPFILES +../internal/tsrc/group/storageservertest.mmp diff -r d27dfa8884ad -r da2cedce4920 analyzetool/storageserver/inc/atstorageservercommon.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/storageserver/inc/atstorageservercommon.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,77 @@ +/* +* 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: Includes common constants and enums for the AnalyzeTool +* StorageServer client and server. +* +*/ + + + +#ifndef ATSTORAGESERVERCOMMON_H +#define ATSTORAGESERVERCOMMON_H + + +// INCLUDES + +#include + + +// CONSTANTS + +// Server's file name +_LIT(KStorageServerFile, "AToolStorageServer.exe"); + +// server name +_LIT(KStorageServerName,"AToolStorageServer"); + + +// The path of the storage file +#ifdef __WINS__ +_LIT( KATDataFilePath, ":\\logs\\analyzetool\\" ); +#else +_LIT( KATDataFilePath, ":\\analyzetool\\" ); +_LIT( KATDataFilePath2, ":\\data\\analyzetool\\" ); +#endif + +// The word size in the current system is 32 bits, which is 4 bytes. +const TInt KWordSize = 4; + +// Leak array granularity value +const TInt KLeakArrayGranularity = 100; + +// DATA TYPES + +/** Storage Server panic codes */ +enum TStorageServerPanics + { + EAToolBadRequest = 1, // An undefined operation request from the client + EAToolBadArgument, // Illegal arguments / function parameters + EAToolNotAllowed, // An operation is not allowed in the current program state + EAToolInternalError, // An internal error has occured + EAToolIllegalLogOption // An undefined log option has been requested + }; + + +/** Panic categories */ +_LIT(KCategoryServer,"STSEServer"); +_LIT(KCategoryClient,"STSEClient"); + +inline void StorageServerPanic( const TDesC &aCategory, TStorageServerPanics aReason ) + { + User::Panic(aCategory, aReason); + } + +#endif // ATSTORAGESERVERCOMMON_H + +// End of File diff -r d27dfa8884ad -r da2cedce4920 analyzetool/storageserver/server/group/atoolstorageserver.mmp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/storageserver/server/group/atoolstorageserver.mmp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,50 @@ +/* +* 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: The .mmp file for the server side of AToolStorageServer +* +*/ + +#include + +TARGET atoolstorageserver.exe +TARGETTYPE exe +UID 0x0 0x20012430 +CAPABILITY NONE + +SMPSAFE + +EPOCHEAPSIZE 0x10000 0x800000 + +SOURCEPATH ../src + +SOURCE atstorageserver.cpp +SOURCE atstorageserversession.cpp +SOURCE atmemoryentry.cpp +SOURCE atdynprocessinfo.cpp +SOURCE atdriveinfo.cpp +SOURCE atdllinfo.cpp + +USERINCLUDE ../inc +USERINCLUDE ../../inc +USERINCLUDE ../../../inc + +OS_LAYER_SYSTEMINCLUDE + +LIBRARY euser.lib +LIBRARY efsrv.lib +LIBRARY flogger.lib +LIBRARY charconv.lib +LIBRARY platformenv.lib + +// End of File diff -r d27dfa8884ad -r da2cedce4920 analyzetool/storageserver/server/inc/atdllinfo.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/storageserver/server/inc/atdllinfo.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,96 @@ +/* +* 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: Declaration of the class TATDllInfo. +* +*/ + + +#ifndef ATDLLINFO_H +#define ATDLLINFO_H + +// INCLUDES +#include + +/** +* Stores information of process loaded library +*/ +class TATDllInfo + { + + public: // Constructors + + /** + * C++ default constructor. + * @param aStartAddress Start address of the library + * @param aEndAddress The end address of the library + * @param aLoadTime The current time in a 64-bit form. + * @param aDllName The name of the library + */ + TATDllInfo( const TUint32 aStartAddress, const TUint32 aEndAddress, + const TInt64& aLoadTime, const TDesC8& aDllName ); + + public: // New functions + + /** + * Returs library start address + * @return TUint32 start address of the library + */ + TUint32 StartAddress(); + + /** + * Returns library end address + * @return TUint32 end address of the library + */ + TUint32 EndAddress(); + + /** + * Gets specific library name + * return TDes8 Name of the library + */ + TDes8& Name(); + + /** + * Returns library load time + * @return TInt64 library load time + */ + TInt64 LibraryLoadTime(); + + /** + * Checks if two objects of this class match based on the objects's + * saved library name. + * @param aFirst Library object + * @param aSecond Library object + * return TBool ETrue, if the two objects match. EFalse otherwise. + */ + static TBool Match( const TATDllInfo& aFirst, const TATDllInfo& aSecond ); + + public: // Member variables + + /* Start address of the loaded dll */ + const TUint32 iStartAddress; + + /* End address of the loaded dll */ + const TUint32 iEndAddress; + + /* Loaded dll name */ + TBuf8 iName; + + /** For storing the time when DLL has loaded. */ + const TInt64 iLoadTime; + }; + +#endif // ATDLLINFO_H + +// End of File + diff -r d27dfa8884ad -r da2cedce4920 analyzetool/storageserver/server/inc/atdriveinfo.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/storageserver/server/inc/atdriveinfo.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,67 @@ +/* +* 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: Declaration of the class TATDriveInfo. +* +*/ + + + +#ifndef ATDRIVEINFO_H +#define ATDRIVEINFO_H + +#include + +/** +* Check what drives exists and creates file full path. +*/ +class TATDriveInfo + { + public: // Constructors + + /** + * C++ default constructor. + */ + TATDriveInfo(); + + public: // New functions + + /** + * Create the file full path. + * @param aPath Full path. + * @param aFileName Filename. + * @param aFs A handle to a file server. + * @return KErrNone or KErrAlreadyExists, if successful; + * Otherwise one of the other system wide error codes. + */ + static TInt CreatePath( TDes& aPath, const TDesC& aFileName, RFs& aFs ); + + private: // New functions + + /** + * Get the available drive character. + * @param aDrive The drive letter. + * @param aDriveNumber The drive number. + * @param aFs A handle to a file server. + * @param aDriveType Drive type. + * @return KErrNone, if successful; otherwise KErrNotFound + */ + static TInt GetDrive( TChar& aDrive, TInt& aDriveNumber, + RFs& aFs, const TUint aDriveType ); + + }; + +#endif // ATDRIVEINFO_H + +// End of File + diff -r d27dfa8884ad -r da2cedce4920 analyzetool/storageserver/server/inc/atdynprocessinfo.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/storageserver/server/inc/atdynprocessinfo.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,102 @@ +/* +* 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: Declaration of the class CATDynProcessInfo +* +*/ + + +#ifndef ATDYNPROCESSINFO_H +#define ATDYNPROCESSINFO_H + + +// INCLUDES +#include +#include +#include "atdllinfo.h" + +// FORWARD DECLARATIONS +class CATStorageServerSession; + +// CLASS DECLARATION + +/** +* A class that can store different process related information. The information +* is associated to a particular process wiht a member telling a process ID. +* All the other information but the process ID and the pointer to this process's +* associated session object can be subject to change dynamically, run-time. +*/ +class CATDynProcessInfo : public CBase + { + public: // Constructor + + /** + * Constructor. + */ + CATDynProcessInfo(); + + /** + * Constructor. + * @param aProcessId A process ID. + * @param aSessionObject A pointer to this process's associated session object. + * @param aDlls The loaded DLLs of the associated process. + */ + CATDynProcessInfo( TUint aProcessId, + CATStorageServerSession* aSessionObject, + const RArray& aDlls ); + + /** + * Constructor. + * @param aProcessId A process ID. + * @param aSessionObject A pointer to this process's associated session object. + */ + CATDynProcessInfo( TUint aProcessId, + CATStorageServerSession* aSessionObject ); + + /** + * Constructor. + * @param aProcessId A process ID. + */ + CATDynProcessInfo( TUint aProcessId ); + + /** + * Destructor + */ + virtual ~CATDynProcessInfo(); + + public: + + /** + * Compares two objects of this class based on the process ID. + * @param aFirst The first object of this class to be compared. + * @param aSecond The second object of this class to be compared. + * @return Zero, if the two objects are equal. A negative value, + * if the first object is less than the second. A positive value, + * if the first object is greater than the second. + */ + static TInt Compare( const CATDynProcessInfo& aFirst, + const CATDynProcessInfo& aSecond ); + + public: + + /** The ID of the process. */ + const TUint iProcessId; + + /** A pointer to the session object associated with this process. */ + CATStorageServerSession* const iSessionObject; + + /** The DLLs loaded by the associated process */ + RArray iDlls; + }; + +#endif // ATDYNPROCESSINFO_H diff -r d27dfa8884ad -r da2cedce4920 analyzetool/storageserver/server/inc/atmemoryentry.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/storageserver/server/inc/atmemoryentry.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,98 @@ +/* +* 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: Declaration of the class CATMemoryEntry +* +*/ + + +#ifndef ATMEMORYENTRY_H +#define ATMEMORYENTRY_H + + +// INCLUDES +#include + + +// CLASS DECLARATION + +/** +* A class for storing memory entries when the server is informed that memory has been +* allocated. The class stores the memory address of a new allocation and a pointer to +* a buffer including the current call stack. It also stores a time stamp, and the size +* of the allocation. +* The class has member methods for evaluating two different objects of this class +* with each other. In the construction the class takes a pointer to the call stack +* buffer, but it does not create the buffer itself. However, it is responsible for +* deleting the buffer in the destruction. +*/ +class CATMemoryEntry : public CBase + { + public: // Constructor + + /** + * Constructor. + * @param aMemAddress An address to allocated memory. + * @param aCallstackBuf A pointer to a buffer containing call stack's memory + * addresses. + * @param aAllocTime The current time in a 64-bit form. + * @param aAllocSize The size of an allocated memory chunk. + */ + CATMemoryEntry( TUint32 aMemAddress, const CBufFlat* aCallstackBuf, + const TInt64& aAllocTime, TInt aAllocSize ); + + /** + * Destructor + */ + virtual ~CATMemoryEntry(); + + public: + /** + * Compares two objects of this class based on the allocation time. + * @param aFirst The first object of this class to be compared. + * @param aSecond The second object of this class to be compared. + * @return Zero, if the two objects are equal. A negative value, + * if the first object is less than the second. A positive value, + * if the first object is greater than the second. + */ + static TInt Compare( const CATMemoryEntry& aFirst, + const CATMemoryEntry& aSecond ); + + /** + * Checks if two objects of this class match based on the objects's + * saved memory allocation addresses. + * @param aFirst The first object of this class to be evaluated. + * @param aSecond The second object of this class to be evaluated. + * @return ETrue, if the two objects match. EFalse otherwise. + */ + static TBool Match( const CATMemoryEntry& aFirst, + const CATMemoryEntry& aSecond ); + + public: + + /** For storing an address of a memory allocation. */ + const TUint32 iMemAddress; + + /** A pointer to an array for storing the current call stack. */ + const CBufFlat* const iCallstackBuf; + + /** For storing the time when an allocation has occured. */ + const TInt64 iAllocTime; + + /** For storing the size of an allocation. */ + const TInt iAllocSize; + + }; + + +#endif // ATMEMORYENTRY_H diff -r d27dfa8884ad -r da2cedce4920 analyzetool/storageserver/server/inc/atstorageserver.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/storageserver/server/inc/atstorageserver.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,218 @@ +/* +* 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: Declaration of the server side main class CATStorageServer +* +*/ + + +#ifndef ATSTORAGESERVER_H +#define ATSTORAGESERVER_H + + +// INCLUDES +#include +#include +#include "atdllinfo.h" + +// CONSTANTS +// Constants for the server's version +const TUint KVersionNumberMaj = 0; +const TUint KVersionNumberMin = 1; +const TUint KVersionNumberBld = 1; + +// DATA TYPES + +// FORWARD DECLARATIONS +class TATProcessInfo; +class CATDynProcessInfo; +class CATStorageServerSession; + +// CLASS DECLARATION + +/** +* The main class of the Storage Server. +* When a client connects to the server, a new session object +* is created by an object of this class. If the server does not exist when +* connecting, a new process and an object of this class are created first. +*/ +class CATStorageServer : public CPolicyServer + { + + public: // Enumerations + + // opcodes used in message passing between client and server + enum TStorageServerReq + { + EProcessStarted, + EDllLoaded, + EDllUnloaded, + EMemoryAllocated, + EMemoryFreed, + EProcessEnded, + EMemoryCheck, + EGetProcesses, + EGetDlls, + ESetLoggingMode, + EGetLoggingMode, + ESubtestStart, + ESubtestStop, + ESubtestStart2, + ESubtestStop2, + EGetCurrentAllocs, + EGetMaxAllocs, + ECancelLogging, + EGetUdeb, + EGetLoggingFile, + EProcessUdeb, + EIsMemoryAdded, + EOutOfBounds + }; + + + public: // Constructors and destructor + + /** + * Two-phased constructor that can leave. + * @return A new instance of this class + */ + static CATStorageServer* NewL(); + + /** + * Two-phased constructor that can leave and leaves a pointer + * on the cleanup stack. + * @return A new instance of this class + */ + static CATStorageServer* NewLC(); + + /** + * Destructor + */ + virtual ~CATStorageServer(); + + public: // New functions + + + /** + * Creates a new server object and starts the server. + */ + static void RunServerL(); + + /** + * Increments the count of active sessions for this server. + */ + void IncSessionCount(); + + /** + * Decrements the count of active sessions for this server. + */ + void DecSessionCount(); + + /** + * Adds a new process into the server's arrays. + * @param aProcessName The name of the process to be added. + * @param aProcessId The ID of the process to be added. + * @param aSessionObject A pointer to the current process's associated session + * object. + * @param aStartTime The starting time of the process to be added. It represents + * time as a number of microseconds since midnight, January 1st, 0 AD nominal + * Gregorian. This is the representation used by, e.g., the TTime class. + * @return KErrNone, if the operation is successful; KErrAlreadyExists, if + * an attempt is being made to insert a duplicate process; otherwise one of + * the other system wide error codes. + */ + TInt AddProcessL( const TDesC8& aProcessName, + TUint aProcessId, + CATStorageServerSession* aSessionObject, + const TInt64& aStartTime ); + + /** + * Removes a process from the server's arrays. + * @param aProcessId The ID of the process to be removed. + * @return KErrNone, if successful; KErrNotFound, if a process with + * the specified process ID could not be found in the array. + */ + TInt RemoveProcessL( TUint aProcessId ); + + /** + * Adds a DLL for a given process to the dynamic process info array of this class. + * @param aProcessId The ID of the process that has loaded the DLL to be added. + * @param aDllInfo Information of the DLL. + * @return KErrNone, if successful; KErrNotFound, if a process with the given + * process ID could not be found; KErrAlreadyExists, if a DLL with the given + * name was already stored; otherwise one of the other system wide error codes. + */ + TInt AddDllL( TUint aProcessId, const TATDllInfo aDllInfo ); + + /** + * Removes a DLL associated with the given process from the dynamic process + * info array of this class. + * @param aProcessId The ID of the process that has loaded the DLL to be removed. + * @param aDllName The name of the DLL to be removed. + * @return KErrNone, if successful; KErrNotFound, if a process with + * the specified process ID could not be found, or if a DLL with the specified + * name could not be found. + */ + TInt RemoveDllL( TUint aProcessId, const TDesC8& aDllName ); + + /** + * Gives a reference to the process info array of this class. + * @return A reference to iProcesses array + */ + const RArray& ProcessInfoArray(); + + /** + * Gives a reference to the dynamic process info array of this class. + * @return A reference to iProcessesDyn array + */ + const RPointerArray& DynProcessInfoArray(); + + public: // Functions from base classes + + /** + * From CPolicyServer. + * Creates a new server-side session object. + * @param aVersion The version of this server + * @param aMessage A message from the client + * @return A pointer to a new session object. + */ + CSession2* NewSessionL( const TVersion& aVersion, const RMessage2& aMessage ) const; + + private: + + /** + * C++ default constructor. + * @param aPriority A priority for this active object + */ + CATStorageServer( TInt aPriority ); + + /** + * Symbian 2nd phase constructor. + */ + void ConstructL(); + + private: // Data + + /** The number of active sessions */ + TInt iSessionCount; + + /** An array for storing TATProcessInfo objects */ + RArray iProcesses; + + /** An array for storing CATDynProcessInfo pointers */ + RPointerArray iProcessesDyn; + }; + +#endif // ATSTORAGESERVER_H + +// End of File \ No newline at end of file diff -r d27dfa8884ad -r da2cedce4920 analyzetool/storageserver/server/inc/atstorageserversession.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/storageserver/server/inc/atstorageserversession.h Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,588 @@ +/* +* 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: Declaration of the server side session class CATStorageServerSession +* +*/ + + +#ifndef ATSTORAGESERVERSESSION_H +#define ATSTORAGESERVERSESSION_H + + +// INCLUDES +#include +#include +#include + +// FORWARD DECLARATIONS +class CATStorageServer; +class CATMemoryEntry; + +// CLASS DECLARATIONS + +/** +* A class for storing memory addresses and sizes of allocations. +* Needed for giving allocation information for the configuration UI. +*/ +class TAllocInfo + { + public: + + // Constructor + TAllocInfo( TUint32 aMemAddress, TInt aAllocSize ); + + /** Address of a memory allocation. */ + const TUint32 iMemAddress; + + /** Size of the associated allocation. */ + const TInt iAllocSize; + }; + + +/** +* The session class for Storage Server. +* When the Storage Server client connects to the server, a new object of this +* class is constructed. So, for every client there is an associated object +* of this class. CATStorageServer forwards all client messages to their associated +* session objects. +*/ +class CATStorageServerSession : public CSession2 + { + public: // Enumerations + + public: // Constructors and destructor + + /** + * Two-phased constructor that can leave. + * @return A new instance of this class + */ + static CATStorageServerSession* NewL( CATStorageServer& aStorageServer ); + + /** + * Two-phased constructor that can leave and leaves a pointer + * on the cleanup stack. + * @return A new instance of this class + */ + static CATStorageServerSession* NewLC( CATStorageServer& aStorageServer ); + + /** + * Destructor + */ + virtual ~CATStorageServerSession(); + + public: // Functions from base classes + + /** + * Receives messages sent by a client. + * @param aMessage A message from a client + */ + virtual void ServiceL( const RMessage2& aMessage ); + + protected: // new functions + + /** + * Initializes this session for logging. This includes opening a logging file + * with a requested name. The method is to be called as the first method after + * connecting to the server. The method logs information on process starting into + * the just opened logging file. + * If a logging session is already ongoing, the method makes the client raise an + * STSEClient: 3 panic, and returns KErrCancel. + * @param aMessage A message that includes parameters sent by the client. + * @return KErrNone, if successful; KErrCancel, if a logging session is already + * ongoing. Otherwise one of the other system wide error codes. + */ + TInt LogProcessStartedL( const RMessage2& aMessage ); + + /** + * Initializes this session for logging. The method is to be called as the first + * method after connecting to the server. The method logs information on process + * starting into debug channel. + * If a logging session is already ongoing, the method makes the client raise an + * STSEClient: 3 panic, and returns KErrCancel. + * @param aMessage A message that includes parameters sent by the client. + * @return KErrNone, if successful; KErrCancel, if a logging session is already + * ongoing. Otherwise one of the other system wide error codes. + */ + TInt LogProcessStartTraceL( const RMessage2& aMessage ); + + /** + * Logs information on a DLL load into the opened file. + * If a logging session is not ongoing, the method makes the client raise an + * STSEClient: 3 panic, and returns KErrCancel. + * @param aMessage A message that includes parameters sent by the client. + * @return KErrNone, if successful; KErrCancel, if a logging session is not + * currently ongoing; Otherwise one of the other system wide error codes. + */ + TInt LogDllLoadedL( const RMessage2& aMessage ); + + /** + * Logs information on a DLL load into debug channel. + * If a logging session is not ongoing, the method makes the client raise an + * STSEClient: 3 panic, and returns KErrCancel. + * @param aMessage A message that includes parameters sent by the client. + * @return KErrNone, if successful; KErrCancel, if a logging session is not + * currently ongoing; Otherwise one of the other system wide error codes. + */ + TInt LogDllLoadTraceL( const RMessage2& aMessage ); + + /** + * Logs information on a DLL unload into the opened file. + * If a logging session is not ongoing, the method makes the client raise an + * STSEClient: 3 panic, and returns KErrCancel. + * @param aMessage A message that includes parameters sent by the client. + * @return KErrNone, if successful; KErrCancel, if a logging session is not + * currently ongoing; Otherwise one of the other system wide error codes. + */ + TInt LogDllUnloadedL( const RMessage2& aMessage ); + + /** + * Logs information on a DLL unload into debug channel. + * If a logging session is not ongoing, the method makes the client raise an + * STSEClient: 3 panic, and returns KErrCancel. + * @param aMessage A message that includes parameters sent by the client. + * @return KErrNone, if successful; KErrCancel, if a logging session is not + * currently ongoing; Otherwise one of the other system wide error codes. + */ + TInt LogDllUnloadTraceL( const RMessage2& aMessage ); + + /** + * Stores a memory allocation (memory address, current call stack, allocation + * time and allocation size) in an internal array. + * If a logging session is not ongoing, the method makes the client raise an + * STSEClient: 3 panic, and returns KErrCancel. + * @param aMessage A message that includes parameters sent by the client. + * @return KErrNone, if successful; KErrCancel, if a logging session is not + * currently ongoing; KErrAlreadyExists, if an attempt is being made to allocate + * again an already allocated memory area; Otherwise one of the other system + * wide error codes. + */ + TInt LogMemoryAllocatedL( const RMessage2& aMessage ); + + /** + * Logs information on a memory allocation into debug channel. + * If a logging session is not ongoing, the method makes the client raise an + * STSEClient: 3 panic, and returns KErrCancel. + * @param aMessage A message that includes parameters sent by the client. + * @return KErrNone, if successful; KErrCancel, if a logging session is not + * currently ongoing; KErrAlreadyExists, if an attempt is being made to allocate + * again an already allocated memory area; Otherwise one of the other system + * wide error codes. + */ + TInt LogMemoryAllocTraceL( const RMessage2& aMessage ); + + /** + * Check a memory allocation (memory address) from an internal array. + * If a logging session is not ongoing, the method makes the client raise an + * STSEClient: 3 panic, and returns KErrCancel. + * @param aMessage A message that includes parameters sent by the client. + * @param aRemoveAlloc Boolean to enable removing the found address from allocations. + * @return KErrNone, if memory address found in array; + * KErrNotFound, if the requested memory address was not found. + */ + TInt IsMemoryAdded( const RMessage2& aMessage, const TBool aRemoveAlloc = EFalse ); + + /** + * Removes a memory allocation (memory address, current call stack, allocation + * time and allocation size) from an internal array. + * If a logging session is not ongoing, the method makes the client raise an + * STSEClient: 3 panic, and returns KErrCancel. + * @param aMessage A message that includes parameters sent by the client. + * @return KErrNone, if successful; KErrCancel, if a logging session is not + * currently ongoing; KErrNotFound, if the requested memory address was not + * found; Otherwise one of the other system wide error codes. + */ + TInt LogMemoryFreedL( const RMessage2& aMessage ); + + /** + * Logs information on freeing of a memory allocatin into debug channel. + * If a logging session is not ongoing, the method makes the client raise an + * STSEClient: 3 panic, and returns KErrCancel. + * @param aMessage A message that includes parameters sent by the client. + * @return KErrNone, if successful; KErrCancel, if a logging session is not + * currently ongoing; KErrNotFound, if the requested memory address was not + * found; Otherwise one of the other system wide error codes. + */ + TInt LogMemoryFreedTraceL( const RMessage2& aMessage ); + + /** + * Logs all non-released memory allocations into the opened file as memory leaks. + * Then the method logs a number of possibly occured handle leaks into the file. + * Next, the method logs information on process ending into the logging file. + * Finally, this method closes the logging file opened for the connected process, + * and ends the current logging session. However, this method does not end the + * actual client-server session. + * If a logging session is not ongoing, the method makes the client raise an + * STSEClient: 3 panic, and returns KErrCancel. + * @param aMessage A message that includes parameters sent by the client. + * @return KErrNone, if successful; KErrCancel, if a logging session is not + * currently ongoing; KErrNotSupported if this method is called with a wrong + * process id from the client. Otherwise one of the other system wide error + * codes. + */ + TInt LogProcessEndedL( const RMessage2& aMessage ); + + /** + * Logs a number of possibly occured handle leaks into debug channel. Then, the method + * logs information on process ending into debug channel. The method also + * ends the current logging session. However, this method does not end the actual + * client-server session. + * If a logging session is not ongoing, the method makes the client raise an + * STSEClient: 3 panic, and returns KErrCancel. + * @param aMessage A message that includes parameters sent by the client. + * @return KErrNone, if successful; KErrCancel, if a logging session is not + * currently ongoing; KErrNotSupported if this method is called with a wrong + * process id from the client. Otherwise one of the other system wide error + * codes. + */ + TInt LogProcessEndTraceL( const RMessage2& aMessage ); + + /** + * Checks if a given memory address can be found. + * If a logging session is not ongoing, the method makes the client raise an + * STSEClient: 3 panic, and returns KErrCancel. + * @param aMessage A message that includes parameters sent by the client. + * @return When the system is logging into a file: the index of a found + * memory address, or KErrNotFound, if a matching memory address cannot + * be found. KErrNone, when the system is not logging into a file. + * KErrCancel, if a logging session is not currently ongoing. + */ + TInt CheckMemoryAddressL( const RMessage2& aMessage ); + + /** + * Checks if a given memory address can be found. + * If a logging session is not ongoing, the method makes the client raise an + * STSEClient: 3 panic, and returns KErrCancel. + * @param aMessage A message that includes parameters sent by the client. + * @return When the system is logging into a file: the index of a found + * memory address, or KErrNotFound, if a matching memory address cannot + * be found. KErrNone, when the system is not logging into a file. + * KErrCancel, if a logging session is not currently ongoing. + */ + TInt CheckMemoryAddressTrace( const RMessage2& aMessage ); + + /** + * Gets all the processes currently logging with AnalyzeTool + * @param aMessage A message that includes parameters sent by the client. + * On return a buffer including all the currently logging processes is written + * into this message. + * @return KErrNone, if successful; otherwise one of the other system wide error + * codes. + */ + TInt GetProcessesL( const RMessage2& aMessage ); + + /** + * Gets all the DLLs loaded by the process determined by the parameters. + * @param aMessage A message that includes parameters sent by the client. + * A buffer including all the DLLs loaded by the requested process is + * written into this message. + * @return KErrNone, if successful; KErrNotFound, if the requested process was + * not found; otherwise one of the other system wide error codes. + */ + TInt GetDllsL( const RMessage2& aMessage ); + + /** + * Gets the logging mode of the process determined by the parameters. + * @param aMessage A message that includes parameters sent by the client. + * On return, the logging mode is written into this message. + * @return KErrNone, if successful; KErrNotFound, if the requested process was + * not found; otherwise one of the other system wide error codes. + */ + TInt GetLoggingModeL( const RMessage2& aMessage ); + + /** + * Starts a sub test for the given process. + * @param aMessage A message that includes parameters sent by the client. + * @return KErrNone, if successful; KErrNotFound, if the requested process is not + * found; KErrNotSupported, if the requested process does not have a logging + * session ongoing or its logging mode is not EATLogToTrace; Otherwise one of the + * other system wide error codes. + */ + TInt StartSubtestL( const RMessage2& aMessage ); + + /** + * Stops a sub test for the given process. + * @param aMessage A message that includes parameters sent by the client. + * @return KErrNone, if successful; KErrNotFound, if the requested process is not + * found; KErrNotSupported, if the requested process does not have a logging + * session ongoing or its logging mode is not EATLogToTrace; Otherwise one of the + * other system wide error codes. + */ + TInt StopSubtestL( const RMessage2& aMessage ); + + /** + * Starts a sub test for the calling process. Does not need a PID from the client. + * @param aMessage A message that includes parameters sent by the client. + * @return KErrNone, if successful; KErrNotSupported, if the calling process + * does not have a logging session ongoing or its logging mode is not + * EATLogToTrace; Otherwise one of the other system wide error codes. + */ + TInt StartSubtest2L( const RMessage2& aMessage ); + + /** + * Stops a sub test for the calling process. Does not need a PID from the client. + * @param aMessage A message that includes parameters sent by the client. + * @return KErrNone, if successful; KErrNotSupported, if the calling process + * does not have a logging session ongoing or its logging mode is not + * EATLogToTrace; Otherwise one of the other system wide error codes. + */ + TInt StopSubtest2( const RMessage2& aMessage ); + + /** + * Gets the number and total size of the current memory chunks allocated by the + * requested process. + * @param aMessage A message that includes parameters sent by the client. The + * requested information is written into this message. + * @return KErrNone, if successful; KErrNotFound, if the requested process was + * not found; otherwise one of the other system wide error codes. + */ + TInt GetCurrentAllocsL( const RMessage2& aMessage ); + + /** + * Gets the maximum number of memory chunks and the maximum amount of memory + * allocated by the requested process during the test run. + * @param aMessage A message that includes parameters sent by the client. The + * requested information is written into this message. + * @return KErrNone, if successful; KErrNotFound, if the requested process was + * not found; otherwise one of the other system wide error codes. + */ + TInt GetMaxAllocsL( const RMessage2& aMessage ); + + /** + * Cancels logging for the requested process. After logging of a given process + * has been cancelled, the session associated with that process will not be + * usable anymore. If a process wants to start logging again, it needs to close + * the handle and open it again in order to create a new session. Until then, any + * of the server's methods that can be called by the client will return + * KErrCancel. + * @param aMessage A message that includes parameters sent by the client. + * @return KErrNone, if successful; KErrNotFound, if the requested process was + * not found; otherwise one of the other system wide error codes. + */ + TInt CancelLoggingL( const RMessage2& aMessage ); + + /** + * Gets the logging file of the process determined by the parameters. + * @param aMessage A message that includes parameters sent by the client. + * On return, the logging file is written into this message. + * @return KErrNone, if successful; KErrNotFound, if the requested process was + * not found; otherwise one of the other system wide error codes. + */ + TInt GetLoggingFileL( const RMessage2& aMessage ); + + /** + * Gets the mode of the process determined by the parameters. + * @param aMessage A message that includes parameters sent by the client. + * On return, the logging file is written into this message. + * @return KErrNone, if successful; KErrNotFound, if the requested process was + * not found; otherwise one of the other system wide error codes. + */ + TInt GetUdebL( const RMessage2& aMessage ); + + /** + * Sets the mode of the process determined by the parameters. + * @param aMessage A message that includes parameters sent by the client. + */ + void SetUdeb( const RMessage2& aMessage ); + + private: // New functions for internal use + + /** + * Releases the resources reserved by this object, and before closing the logging + * file and file server session, the method logs information on the occured error + * into the logging file. + * @param aError The error code to be logged. + */ + void HandleError( TInt aError ); + + /** + * Releases the resources reserved by this object, and logs information on the + * occured error into debug channel. + * @param aError The error code to be logged. + */ + void HandleErrorTrace( TInt aError ); + + /** + * Opens a file server session and a file with the name specified. + * @param aFileName The name of the file into which to log. + * @param aProcessName Current process name. + * @return KErrNone, if successful; otherwise one of the other system wide + * error codes. + */ + TInt OpenFsAndFile( const TDesC& aFileName, const TDesC8& aProcessName ); + + /** + * Method is used to parse file name extension. + * @param aFileName The name of the file into which to log. + * @param aExtension Parsed file extension. + */ + void ParseExtension( TDes& aFileName, TDes& aExtension ); + + /** + * Called internally when need generate new file name. + * @param aFileName The name of the file into which to log. + * @param aProcessName Current process name. + */ + void GenerateNewFileName( TDes& aFileName, const TDesC8& aProcessName ); + + /** + * Method is used to check that file exists and is valid. + * @param aFileName The name of the file into which to log. + */ + void CheckIfFileAlreadyExist( const TDes& aFileName ); + + /** + * Method is used to check file version. + * @param aFileName The name of the file into which to log. + */ + void CheckFileVersion( const TDes& aFileName ); + + /** + * Closes the handles to the file server session and to the file (if currently open). + */ + void CloseFsAndFile(); + + /** + * Writes the memory leaks stored in the iLeakArray member array into the + * logging file opened for the current logging session. If the method is + * called in a wrong program state (logging session is not ongoing, or the + * logging mode is not EATLogToFile), STSEClient: 4, and STSEServer: 4 + * panics are raised. + * @param aMessage The current message from the client. + * @return KErrNone, if successful; otherwise one of the other system wide + * error codes. + */ + TInt PrintLeaksL( const RMessage2& aMessage ); + + /** + * Sets the server's mode of operation. The operation mode is determined with + * an enumeration value, which is received from the client. If the method is + * called in a wrong program state (logging session is ongoing), STSEClient: 4, + * and STSEServer: 4 panics are raised. + * @param aMessage The current message from the client. + */ + void SetLogOption( const RMessage2& aMessage ); + + /** + * Logs the given descriptor through debug channel. + * @param aLogString The descriptor to be logged. + * @return KErrNone, if successful; KErrNotSupported, if a logging session is not + * ongoing, or the logging mode is not EATLogToTrace; + */ + TInt LogThroughTrace( const TDesC& aLogString ) const; + + /** + * Gives a reference to the allocation info array of this class. + * @return A reference to iAllocInfoArray array + */ + RArray& AllocInfoArray(); + + /** + * Creates a panic in the associated client's code. + * @param aPanic The panic code + * @param aMessage The message associated with this panic. + */ + void PanicClient( TInt aPanic, const RMessage2& aMessage ); + + /** + * Logs the abnormal end to the debug channel (If logging mode is EATLogToTrace) + * and to the file(If logging mode is EATLogToFile). + */ + void LogAbnormalEnd(); + + /** + * Get the current universal time. + * @return Time + */ + TInt64 GetTime(); + + private: // Constructors + + /** + * C++ default constructor. + */ + CATStorageServerSession( CATStorageServer& aStorageServer ); + + /** + * Symbian 2nd phase constructor. + */ + void ConstructL(); + + private: // Data + + /** A reference to the CATStorageServer object that has created this session */ + CATStorageServer& iStorageServer; + + /** A handle to a file server */ + RFs iFileServer; + + /** A handle to a file */ + RFile iFile; + + /** A member variable for storing results of server function calls. */ + TInt iError; + + /** An object for getting time stamps */ + TTime iTime; + + /** + * An array for storing CATMemoryEntry pointers. Used when logging + * to an S60 file. + */ + RPointerArray iLeakArray; + + /** + * An array for storing TAllocInfo objects. Used for keeping records on memory + * allocations and their sizes. + */ + RArray iAllocInfoArray; + + /** The ID of the process associated with this session. */ + TUint iProcessId; + + /** + * A boolean telling whether this session has been initialized for logging + * ( whether the client's LogProcessStarted() method has been called ) or not. + */ + TBool iLoggingOngoing; + + /** + * A variable telling the number of microseconds from January 1st, 0 AD + * nominal Gregorian to January 1st, 1970 AD nominal Gregorian. + */ + TInt64 iMicroSecondsAt1970; + + /** + * An enumeration that tells the current operation mode of the Storage Server. + */ + TATLogOption iLogOption; + + /** The total size of all the current allocations of this process */ + TUint32 iCurAllocSize; + + /** The maximum number of allocations of this process */ + TUint32 iMaxAllocs; + + /** The maximum total size of allocations of this process */ + TUint32 iMaxAllocSize; + + /** The logging file of this process */ + TBuf8 iLogFile; + + /** The mode of the session. Default is 1 = UDEB */ + TUint32 iIsUdeb; + }; + +#endif // ATSTORAGESERVERSESSION_H + +// End of File diff -r d27dfa8884ad -r da2cedce4920 analyzetool/storageserver/server/src/atdllinfo.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/storageserver/server/src/atdllinfo.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,102 @@ +/* +* 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 TATDllInfo. +* +*/ + +// INCLUDE FILES +#include "atdllinfo.h" +#include "atlog.h" + +// ----------------------------------------------------------------------------- +// TATDllInfo::TATDllInfo +// C++ default constructor. +// ----------------------------------------------------------------------------- +// +TATDllInfo::TATDllInfo( const TUint32 aStartAddress, const TUint32 aEndAddress, + const TInt64& aLoadTime, const TDesC8& aDllName ) + : iStartAddress( aStartAddress ), iEndAddress( aEndAddress ), + iLoadTime( aLoadTime ) + { + LOGSTR3( "STSE TATDllInfo::TATDllInfo() %x - %x", iStartAddress, iEndAddress ); + + iName.Copy( aDllName ); + } + +// ----------------------------------------------------------------------------- +// TATDllInfo::StartAddress +// Returns library start address +// ----------------------------------------------------------------------------- +// +TUint32 TATDllInfo::StartAddress() + { + LOGSTR2( "STSE TATDllInfo::StartAddress( %x )", iStartAddress ); + + return iStartAddress; + } + +// ----------------------------------------------------------------------------- +// TATDllInfo::EndAddress +// Returns library end address +// ----------------------------------------------------------------------------- +// +TUint32 TATDllInfo::EndAddress() + { + LOGSTR2( "STSE TATDllInfo::EndAddress( %x )", iEndAddress ); + + return iEndAddress; + } + +// ----------------------------------------------------------------------------- +// TATDllInfo::Name +// Gets specific library name +// ----------------------------------------------------------------------------- +// +TDes8& TATDllInfo::Name() + { + LOGSTR1( "STSE TATDllInfo::Name()" ); + + return iName; + } + +// ----------------------------------------------------------------------------- +// TATDllInfo::LibraryLoadTime +// Returns library load time +// ----------------------------------------------------------------------------- +// +TInt64 TATDllInfo::LibraryLoadTime() + { + LOGSTR1( "STSE TATDllInfo::LibraryLoadTime()" ); + + return iLoadTime; + } + +// ----------------------------------------------------------------------------- +// TATDllInfo::Match +// Checks if two objects of this class match based on the objects's +// saved library name. +// ----------------------------------------------------------------------------- +// +TBool TATDllInfo::Match( const TATDllInfo& aFirst, const TATDllInfo& aSecond ) + { + LOGSTR1( "STSE TATDllInfo::Match()" ); + + if ( aFirst.iName.Compare( aSecond.iName ) == 0 ) + { + return ETrue; + } + return EFalse; + } + +// End of File diff -r d27dfa8884ad -r da2cedce4920 analyzetool/storageserver/server/src/atdriveinfo.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/storageserver/server/src/atdriveinfo.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,188 @@ +/* +* 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 TATDriveInfo. +* +*/ + + + +// INCLUDE FILES +#include +#include +#include "atdriveinfo.h" +#include "atstorageservercommon.h" +#include "atlog.h" + +// ----------------------------------------------------------------------------- +// TATDriveInfo::TATDriveInfo +// C++ default constructor. +// ----------------------------------------------------------------------------- +// +TATDriveInfo::TATDriveInfo() + { + LOGSTR1( "TATD TATDriveInfo::TATDriveInfo()" ); + } + +// ----------------------------------------------------------------------------- +// TATDriveInfo::CreatePath() +// ----------------------------------------------------------------------------- +// +TInt TATDriveInfo::CreatePath( TDes& aPath, + const TDesC& aFileName, RFs& aFs ) + { + LOGSTR1( "TATD TInt TATDriveInfo::CreatePath()" ); + + // Drive letter + TChar driveLetter; + // Drive number + TInt dNumber( EDriveZ ); + TBool found( EFalse ); + // Drive type + TUint driveType( KDriveAttRemovable ); + TInt err( KErrNotFound ); + + while ( !found ) + { + // Get drive letter + if ( GetDrive( driveLetter, dNumber, aFs, driveType ) == KErrNotFound ) + { + if ( driveType == KDriveAttInternal ) + { + return KErrNotFound; + } + driveType = KDriveAttInternal; + dNumber = EDriveZ; + } + else + { + // Create path + aPath.Delete( 0, aPath.MaxLength() ); + aPath.Append( driveLetter ); + + + #ifdef __WINS__ + // For emulator the data file is stored to different location + aPath.Append( KATDataFilePath ); + #else + TDriveInfo driveInfo; + aFs.Drive( driveInfo, dNumber ); + // The drive is removable( memory card ) so we can log inside of root folder + if ( driveInfo.iDriveAtt & KDriveAttRemovable ) + { + aPath.Append( KATDataFilePath ); + } + // The drive is internal user can only access data folder so log into that + else + { + aPath.Append( KATDataFilePath2 ); + } + #endif + + // Make a directory for AToolStorageServer's logging data file + err = aFs.MkDir( aPath ); + LOGSTR2( "STSE > aFs.MkDir err = %i", err ); + + if ( !err || err == KErrAlreadyExists ) + { + if ( aFileName.Length() != 0 && + ( ( aPath.MaxLength() - aPath.Length() ) > aFileName.Length() ) ) + { + aPath.Append( aFileName ); + } + found = ETrue; + } + } + } + return err; + } + +// ----------------------------------------------------------------------------- +// TATDriveInfo::GetDrive() +// ----------------------------------------------------------------------------- +// +TInt TATDriveInfo::GetDrive( TChar& aDrive, TInt& aDriveNumber, RFs& aFs, + const TUint aDriveType ) + { + LOGSTR1( "TATD TInt TATDriveInfo::GetDrive()" ); + + // Contains drive information. + TDriveInfo driveInfo; + + for ( TInt i = aDriveNumber; i >= (TInt)EDriveA; i-- ) + { + // Gets information about a drive and the medium mounted on it. + // If error occured then skip to next drive. + if ( aFs.Drive( driveInfo, i ) != KErrNone ) + continue; + + // Test whether drive is available. If not, skip to next drive. + if ( driveInfo.iDriveAtt & KDriveAbsent || i == (TInt)EDriveD || + driveInfo.iDriveAtt & KDriveAttRom || + driveInfo.iMediaAtt & KMediaAttWriteProtected || + driveInfo.iDriveAtt & KDriveFileSysROFS ) + continue; + + // Maps a drive number to the corresponding character. + if ( aFs.DriveToChar( i, aDrive ) != KErrNone ) + continue; + + if ( driveInfo.iDriveAtt & aDriveType && + driveInfo.iType != EMediaNotPresent && + driveInfo.iType != EMediaCdRom ) + { + TUint status( 0 ); + + switch ( aDriveType ) + { + case KDriveAttRemovable: + { + // Get the drive status of the default removable mass storage. + if ( DriveInfo::GetDriveStatus( aFs, i, status ) == KErrNone ) + { + // To indicate that the drive is physically removable. + if ( status & DriveInfo::EDriveRemovable && + !( status & DriveInfo::EDriveCorrupt ) ) + { + aDriveNumber = --i; + return KErrNone; + } + } + } + break; + case KDriveAttInternal: + { + // Get the drive status of the default removable mass storage. + if ( DriveInfo::GetDriveStatus( aFs, i, status ) == KErrNone ) + { + // To indicate that the drive is internal and + // cannot be physically removed. + if ( status & DriveInfo::EDriveInternal && + !( status & DriveInfo::EDriveExternallyMountable ) ) + { + aDriveNumber = --i; + return KErrNone; + } + } + } + break; + + default: + break; + } + } + } + return KErrNotFound; + } + +// End of File diff -r d27dfa8884ad -r da2cedce4920 analyzetool/storageserver/server/src/atdynprocessinfo.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/storageserver/server/src/atdynprocessinfo.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,94 @@ +/* +* 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 CATDynProcessInfo +* +*/ + + +// INCLUDE FILES +#include "atdynprocessinfo.h" + +// ============================ MEMBER FUNCTIONS =============================== + + +// ----------------------------------------------------------------------------- +// CATDynProcessInfo::CATDynProcessInfo +// ----------------------------------------------------------------------------- +// +CATDynProcessInfo::CATDynProcessInfo() : + iProcessId( KNullProcessId ), + iSessionObject( NULL ) + { + } + +// ----------------------------------------------------------------------------- +// CATDynProcessInfo::CATDynProcessInfo +// ----------------------------------------------------------------------------- +// +CATDynProcessInfo::CATDynProcessInfo( TUint aProcessId, + CATStorageServerSession* aSessionObject, + const RArray& aDlls ) : + iProcessId( aProcessId ), + iSessionObject( aSessionObject ), + iDlls( aDlls ) + { + } + +// ----------------------------------------------------------------------------- +// CATDynProcessInfo::CATDynProcessInfo +// ----------------------------------------------------------------------------- +// +CATDynProcessInfo::CATDynProcessInfo( TUint aProcessId, + CATStorageServerSession* aSessionObject ) : + iProcessId( aProcessId ), iSessionObject( aSessionObject ) + { + } + +// ----------------------------------------------------------------------------- +// CATDynProcessInfo::CATDynProcessInfo +// ----------------------------------------------------------------------------- +// +CATDynProcessInfo::CATDynProcessInfo( TUint aProcessId ) : + iProcessId( aProcessId ), iSessionObject( NULL ) + { + } + +// Destructor +CATDynProcessInfo::~CATDynProcessInfo() + { + iDlls.Close(); + } + +// ----------------------------------------------------------------------------- +// CATDynProcessInfo::Compare +// ----------------------------------------------------------------------------- +// +TInt CATDynProcessInfo::Compare( const CATDynProcessInfo& aFirst, + const CATDynProcessInfo& aSecond ) + { + if ( aFirst.iProcessId < aSecond.iProcessId ) + { + return -1; + } + + if ( aFirst.iProcessId > aSecond.iProcessId ) + { + return 1; + } + + // else + return 0; + } + +// End of File diff -r d27dfa8884ad -r da2cedce4920 analyzetool/storageserver/server/src/atmemoryentry.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/storageserver/server/src/atmemoryentry.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,84 @@ +/* +* 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 CATMemoryEntry +* +*/ + + + +// INCLUDE FILES +#include "atmemoryentry.h" + + +// ============================ MEMBER FUNCTIONS =============================== + + +// ----------------------------------------------------------------------------- +// CATMemoryEntry::CATMemoryEntry +// C++ default constructor. +// ----------------------------------------------------------------------------- +// +CATMemoryEntry::CATMemoryEntry( TUint32 aMemAddress, + const CBufFlat* aCallstackBuf, + const TInt64& aAllocTime, + TInt aAllocSize ) : + iMemAddress( aMemAddress ), + iCallstackBuf( aCallstackBuf ), + iAllocTime( aAllocTime ), + iAllocSize( aAllocSize ) + { + } + +// Destructor +CATMemoryEntry::~CATMemoryEntry() + { + delete const_cast( iCallstackBuf ); + } + +// ----------------------------------------------------------------------------- +// CATMemoryEntry::Compare +// ----------------------------------------------------------------------------- +// +TInt CATMemoryEntry::Compare( const CATMemoryEntry& aFirst, const CATMemoryEntry& aSecond ) + { + if ( aFirst.iAllocTime < aSecond.iAllocTime ) + { + return -1; + } + + if ( aFirst.iAllocTime > aSecond.iAllocTime ) + { + return 1; + } + + // else + return 0; + } + +// ----------------------------------------------------------------------------- +// CATMemoryEntry::Match +// ----------------------------------------------------------------------------- +// +TBool CATMemoryEntry::Match( const CATMemoryEntry& aFirst, const CATMemoryEntry& aSecond ) + { + if ( aFirst.iMemAddress == aSecond.iMemAddress ) + { + return ETrue; + } + + // else + return EFalse; + } + + diff -r d27dfa8884ad -r da2cedce4920 analyzetool/storageserver/server/src/atstorageserver.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/storageserver/server/src/atstorageserver.cpp Tue May 25 14:22:58 2010 +0300 @@ -0,0 +1,452 @@ +/* +* 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 CATStorageServer. Includes also the +* entry point of the atoolstorageserver.exe executable. +* +*/ + + + + +// INCLUDE FILES + +#include "atstorageserver.h" +#include "atstorageserversession.h" +#include "atstorageservercommon.h" +#include "atlog.h" +#include "atdynprocessinfo.h" + + +// CONSTANTS + + +// The amount of different ranges of requests specified for this policy server. +// In a policy server, different actions can be determined for different ranges +// of requests. +const TUint8 KAmountOfRanges = 2; + + +const TInt ranges[KAmountOfRanges] = + { + CATStorageServer::EProcessStarted, + CATStorageServer::EOutOfBounds + }; + + +const TUint8 actionForRange[ KAmountOfRanges ] = + { 0, CPolicyServer::ENotSupported }; + + +const CPolicyServer::TPolicyElement elements[] = + { + + { _INIT_SECURITY_POLICY_C1( ECapability_None ), + CPolicyServer::EFailClient } + + }; + + +const CPolicyServer::TPolicy policy = + { + CPolicyServer::EAlwaysPass, // On connect + KAmountOfRanges, // Range count + ranges, + actionForRange, + elements, + }; + + + +// ENTRY POINT + +TInt E32Main() + { + LOGSTR1( "STSE TInt E32Main() in ATStorageServer.cpp" ); + + __UHEAP_MARK; + + // Create a cleanup stack + CTrapCleanup* cleanup = CTrapCleanup::New(); + + TInt errorCode( KErrNoMemory ); + + // If there was enough memory to create a cleanup stack, + // create and start the server. + if( cleanup ) + { + // If RunServerL() doesn't leave, errorCode will be set to KErrNone + TRAP( errorCode, CATStorageServer::RunServerL() ); + delete cleanup; + } + + // Signal the client that server creation failed, if a leave occured during + // the call to 'RunServerL()' function + if( errorCode != KErrNone ) + { + RProcess::Rendezvous( errorCode ); + } + + __UHEAP_MARKEND; + + return errorCode; + + } + + +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// CATStorageServer::CATStorageServer +// C++ default constructor can NOT contain any code that +// might leave. +// ----------------------------------------------------------------------------- +// +CATStorageServer::CATStorageServer( TInt aPriority ) : + CPolicyServer( aPriority, policy, ESharableSessions ), + iSessionCount( 0 ) + { + LOGSTR1( "STSE CATStorageServer::CATStorageServer()" ); + } + +// ----------------------------------------------------------------------------- +// CATStorageServer::ConstructL +// Symbian 2nd phase constructor can leave. +// ----------------------------------------------------------------------------- +// +void CATStorageServer::ConstructL() + { + } + +// ----------------------------------------------------------------------------- +// CATStorageServer::NewL +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +CATStorageServer* CATStorageServer::NewL() + { + CATStorageServer* self = NewLC(); + CleanupStack::Pop( self ); + + return self; + } + +// ----------------------------------------------------------------------------- +// CATStorageServer::NewLC +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +CATStorageServer* CATStorageServer::NewLC() + { + CATStorageServer* self = new ( ELeave ) CATStorageServer( EPriorityStandard ); + CleanupStack::PushL( self ); + self->ConstructL(); + self->StartL( KStorageServerName ); + return self; + } + +// Destructor +CATStorageServer::~CATStorageServer() + { + LOGSTR1( "STSE CATStorageServer::~CATStorageServer()" ); + + iProcesses.Close(); + iProcessesDyn.ResetAndDestroy(); + iProcessesDyn.Close(); + } + +// ----------------------------------------------------------------------------- +// CATStorageServer::NewSessionL +// Create a new server session. +// ----------------------------------------------------------------------------- +// +CSession2* CATStorageServer::NewSessionL( + const TVersion &aVersion, + const RMessage2& /*aMessage*/ ) const + { + LOGSTR1( "STSE CSession2* CATStorageServer::NewSessionL()" ); + + // The server's version + TVersion version( KVersionNumberMaj, KVersionNumberMin, + KVersionNumberBld ); + + // Check this is a high enough version of the server + if ( !User::QueryVersionSupported(version, aVersion) ) + { + User::Leave( KErrNotSupported ); + } + + // Construct and return a new session object + return CATStorageServerSession::NewL( const_cast(*this) ); + } + +// ----------------------------------------------------------------------------- +// CATStorageServer::RunServerL +// Create active scheduler and a server object +// ----------------------------------------------------------------------------- +// +void CATStorageServer::RunServerL() + { + LOGSTR1( "STSE void CATStorageServer::RunServerL()" ); + + // Create and install an active scheduler + CActiveScheduler* activeSched = new (ELeave) CActiveScheduler; + CleanupStack::PushL( activeSched ); + CActiveScheduler::Install( activeSched ); + + // Create server + CATStorageServer::NewLC(); + + // The initialization performed alright, signal the client + RProcess::Rendezvous( KErrNone ); + + // Start the active scheduler + CActiveScheduler::Start(); + + // Remove the server and active scheduler from the cleanup stack + CleanupStack::PopAndDestroy( 2, activeSched ); + } + +// ----------------------------------------------------------------------------- +// CATStorageServer::IncSessionCount +// Increments the count of active sessions for this server. +// ----------------------------------------------------------------------------- +// +void CATStorageServer::IncSessionCount() + { + LOGSTR1( "STSE void CATStorageServer::IncSessionCount()" ); + + iSessionCount++; + } + +// ----------------------------------------------------------------------------- +// CATStorageServer::DecSessionCount +// Decrements the count of active sessions for this server. +// ----------------------------------------------------------------------------- +// +void CATStorageServer::DecSessionCount() + { + LOGSTR1( "STSE void CATStorageServer::DecSessionCount()" ); + + iSessionCount--; + + // Cancels all outstanding messages and stops the active scheduler, + // if there are no other sessions open at the moment + if ( iSessionCount <= 0 ) + { + this->Cancel(); + CActiveScheduler::Stop(); + } + } + +// ----------------------------------------------------------------------------- +// CATStorageServer::AddProcessL +// ----------------------------------------------------------------------------- +// +TInt CATStorageServer::AddProcessL( const TDesC8& aProcessName, + TUint aProcessId, + CATStorageServerSession* aSessionObject, + const TInt64& aStartTime ) + { + LOGSTR1( "STSE TInt CATStorageServer::AddProcessL()" ); + + TInt error( KErrNone ); + TATProcessInfo processInfo; + + processInfo.iProcessId = aProcessId; + processInfo.iProcessName.Copy( aProcessName ); + processInfo.iStartTime = aStartTime; + + // Insert the static process info into the iProcesses array + error = iProcesses.InsertInUnsignedKeyOrder( processInfo ); + + // Return if an error occured + if ( error != KErrNone) + { + return error; + } + + // Construct a CATDynProcessInfo object with the given process ID and logging mode + CATDynProcessInfo* dynProcessInfo = + new (ELeave) CATDynProcessInfo( aProcessId, + aSessionObject ); + + // Insert the dynamic process info into the iProcessesDyn array + TLinearOrder