--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tracesrv/tracecore/btrace_handler/test/TEF/te_tracecore/src/te_tracecore_datawrapper.cpp Fri Oct 08 14:56:39 2010 +0300
@@ -0,0 +1,2012 @@
+// Copyright (c) 2005-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".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+//
+//
+#include <bautils.h>
+#include <test/tracedataparser.h>
+
+#include "te_tracecore_datawrapper.h"
+#include "te_processcreator.h"
+
+_LIT(KConstantsSectionName, "Constants");
+
+_LIT(KCmdCopyFile, "CopyFile");
+_LIT(KCmdDeleteFile, "DeleteFile");
+_LIT(KCmdDeleteFileFromAllDrives, "DeleteFileFromAllDrives");
+_LIT(KCmdDeleteEmptyFolder, "DeleteEmptyFolder");
+_LIT(KCmdFileExists, "FileExists");
+_LIT(KCmdRunProcess, "RunProcess");
+_LIT(KCmdCheckFileSize, "CheckFileSize");
+_LIT(KCmdCreateSubstDrive, "CreateSubstDrive");
+_LIT(KCmdUnSubstDrive, "UnSubstDrive");
+_LIT(KCmdCheckMaxFileSize, "CheckMaxFileSize");
+_LIT(KCmdCheckFileIsAppended, "CheckFileIsAppended");
+_LIT(KCmdVerifyTraceData, "VerifyTraceData");
+_LIT(KCmdVerifyPrimingData, "VerifyPrimingData");
+_LIT(KCmdVerifyDroppedTraces, "VerifyDroppedTraces");
+_LIT(KCmdVerifySlot, "VerifySlot");
+_LIT(KCmdFileChangeNotification, "FileChangeNotification");
+_LIT(KCmdSetUpTraceOnActivation, "SetUpTraceOnActivation");
+_LIT(KCmdRegisterNotifReceiver, "RegisterNotifReceiver");
+_LIT(KCmdUnregisterNotifReceiver, "UnregisterNotifReceiver");
+_LIT(KCmdCleanUpTraceOnActivation, "CleanUpTraceOnActivation");
+_LIT(KCmdInstrumentTraceSequence, "InstrumentTraceSequence");
+_LIT(KCmdSetUpTcLdd, "SetUpTcLdd");
+_LIT(KCmdCleanUpTcLdd, "CleanUpTcLdd");
+_LIT(KCmdSetUpTcOstLdd, "SetUpTcOstLdd");
+_LIT(KCmdCleanUpTcOstLdd, "CleanUpTcOstLdd");
+_LIT(KCmdActivateDeactivateTrace, "ActivateDeactivateTrace");
+_LIT(KCmdReadTracesFromBuffer, "ReadTracesFromBuffer");
+
+_LIT(KSrcFileKey, "src_file");
+_LIT(KDstFileKey, "dst_file");
+_LIT(KFileKey, "file");
+_LIT(KExeNameKey, "exe_name");
+_LIT(KArgsKey, "args");
+_LIT(KNoOfCallsKey, "calls");
+_LIT(KNoOfAllowedTimeoutsKey, "allowed_timeouts");
+_LIT(KFolderPathKey, "path");
+_LIT(KDriveKey, "drive");
+_LIT(KSizeKey, "size");
+_LIT(KMinSizeKey, "min_size");
+_LIT(KMaxSizeKey, "max_size");
+_LIT(KSystemDriveKey, "system_drive");
+_LIT(KUnfetteredKey, "unfettered");
+_LIT(KDurationKey, "duration");
+_LIT(KMinIncreaseKey, "min_increase");
+_LIT(KGroupIdKey, "group_id");
+_LIT(KComponentIdKey, "component_id");
+_LIT(KSlotNumberKey, "slot");
+_LIT(KTracesSlotNumberKey, "traces_slot");
+_LIT(KPrimingTracesSlotNumberKey, "priming_traces_slot");
+_LIT(KSlotANumberKey, "slot_a");
+_LIT(KSlotBNumberKey, "slot_b");
+_LIT(KValueAKey, "value_a");
+_LIT(KValueBKey, "value_b");
+_LIT(KDifferenceKey, "difference");
+_LIT(KMinDifferenceKey, "min_difference");
+_LIT(KMaxDifferenceKey, "max_difference");
+_LIT(KVerifyData, "verify_data");
+_LIT(KFindStringKey, "find_string");
+_LIT(KExpectedKey, "expected");
+_LIT(KLengthKey, "length");
+_LIT(KStringKey, "string");
+_LIT(KActivateKey, "activate");
+_LIT(KBufferSizeKey, "buffer_size");
+_LIT(KAllowErrorKey, "allow_error");
+_LIT(KSingleUseKey, "single_use");
+_LIT(KOpenLddKey, "open_ldd");
+_LIT(KCloseLddKey, "close_ldd");
+
+_LIT(KSpace, " ");
+_LIT(KInt, "%d");
+
+_LIT(KTcLdd, "TcLdd");
+_LIT(KTraceCoreOstLdd, "TraceCoreOstLdd");
+_LIT(KTraceOnActivationLdd, "d_traceonactivation.ldd");
+
+const TInt KSecondsToMicroSeconds = 1000000;
+const TInt KDefaultBufferSize = 1024;
+const TInt KLongStringLength = 512;
+
+
+CTraceCoreDataWrapper::CTraceCoreDataWrapper()
+: iActiveFileChangeNotification(NULL)
+, iActiveFileChangeNotificationTimeout(NULL)
+, iTcLddLoadedAtStart(EFalse)
+, iTcOstLddLoadedAtStart(EFalse)
+, iTraceOnActivationLoadedAtStart(EFalse)
+ {
+ }
+
+CTraceCoreDataWrapper::~CTraceCoreDataWrapper()
+ {
+ delete iActiveFileChangeNotification;
+ delete iActiveFileChangeNotificationTimeout;
+ iFs.Close();
+ iTimer.Close();
+ iTraceBuffer.Close();
+ iTcLdd.Close();
+ iTraceCoreOstLdd.Close();
+ iTraceOnActivationLdd.Close();
+ }
+
+CTraceCoreDataWrapper* CTraceCoreDataWrapper::NewLC()
+ {
+ CTraceCoreDataWrapper* self = new (ELeave)CTraceCoreDataWrapper();
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ return self;
+ }
+
+CTraceCoreDataWrapper* CTraceCoreDataWrapper::NewL()
+ {
+ CTraceCoreDataWrapper* self=CTraceCoreDataWrapper::NewLC();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+void CTraceCoreDataWrapper::ConstructL()
+ {
+ User::LeaveIfError(iFs.Connect());
+ User::LeaveIfError(iTimer.CreateLocal());
+ iActiveFileChangeNotification = CActiveCallback::NewL(*this);
+ iActiveFileChangeNotificationTimeout = CActiveCallback::NewL(*this);
+ }
+
+TAny* CTraceCoreDataWrapper::GetObject()
+ {
+ return this;
+ }
+
+TBool CTraceCoreDataWrapper::GetStringFromConfig(const TDesC& aSectName, const TDesC& aKeyName, TPtrC& aResult)
+ {
+ TBool found = CDataWrapper::GetStringFromConfig(aSectName, aKeyName, aResult);
+ if (found)
+ {
+ TPtrC constantName(aResult);
+ CDataWrapper::GetStringFromConfig(KConstantsSectionName(), constantName, aResult);
+ }
+ return found;
+ }
+
+TBool CTraceCoreDataWrapper::GetBoolFromConfig(const TDesC& aSectName, const TDesC& aKeyName, TBool& aResult)
+ {
+ TBool found = CDataWrapper::GetIntFromConfig(aSectName, aKeyName, aResult);
+ if (!found)
+ {
+ TPtrC constantName;
+ found = CDataWrapper::GetStringFromConfig(aSectName, aKeyName, constantName);
+ if (found)
+ {
+ found = CDataWrapper::GetBoolFromConfig(KConstantsSectionName(), constantName, aResult);
+ if (!found)
+ {
+ found = CDataWrapper::GetBoolFromConfig(aSectName, aKeyName, aResult);
+ }
+ }
+ }
+ return found;
+ }
+
+TBool CTraceCoreDataWrapper::GetIntFromConfig(const TDesC& aSectName, const TDesC& aKeyName, TInt& aResult)
+ {
+ TBool found = CDataWrapper::GetIntFromConfig(aSectName, aKeyName, aResult);
+ if (!found)
+ {
+ TPtrC constantName;
+ found = CDataWrapper::GetStringFromConfig(aSectName, aKeyName, constantName);
+ if (found)
+ {
+ found = CDataWrapper::GetIntFromConfig(KConstantsSectionName(), constantName, aResult);
+ }
+ }
+ return found;
+ }
+
+TBool CTraceCoreDataWrapper::GetHexFromConfig(const TDesC& aSectName, const TDesC& aKeyName, TInt& aResult)
+ {
+ TBool found = CDataWrapper::GetIntFromConfig(aSectName, aKeyName, aResult);
+ if (!found)
+ {
+ TPtrC constantName;
+ found = CDataWrapper::GetStringFromConfig(aSectName, aKeyName, constantName);
+ if (found)
+ {
+ found = CDataWrapper::GetHexFromConfig(KConstantsSectionName(), constantName, aResult);
+ if (!found)
+ {
+ found = CDataWrapper::GetHexFromConfig(aSectName, aKeyName, aResult);
+ }
+ }
+ }
+ else
+ {
+ found = CDataWrapper::GetHexFromConfig(aSectName, aKeyName, aResult);
+ }
+ return found;
+ }
+
+TBool CTraceCoreDataWrapper::GetPathFromConfig(const TTEFSectionName& aSection, const TDesC& aPathKey, TFileName& aPath)
+ {
+ TBool found = EFalse;
+ TPtrC file;
+ if (GetStringFromConfig(aSection, aPathKey, file))
+ {
+ found = ETrue;
+ TBool useSysDrive = EFalse;
+ GetBoolFromConfig(aSection, KSystemDriveKey(), useSysDrive);
+ TPtrC driveString;
+ if (GetStringFromConfig(aSection, KDriveKey(), driveString))
+ {
+ aPath.Zero();
+ aPath.Append(driveString);
+ aPath.Append(_L(":"));
+ aPath.Append(file);
+ }
+ else if (useSysDrive)
+ {
+ aPath.Zero();
+ aPath.Append(RFs::GetSystemDriveChar());
+ aPath.Append(_L(":"));
+ aPath.Append(file);
+ }
+ else
+ {
+ aPath.Copy(file);
+ }
+ }
+ else
+ {
+ ERR_PRINTF2(_L("No %S in INI file"), &aPathKey);
+ SetBlockResult(EFail);
+ }
+ return found;
+ }
+
+TBool CTraceCoreDataWrapper::GetArgsFromConfig(const TTEFSectionName& aSection, TDes& aArgs)
+ {
+ TPtrC cmdLineArgs(KNullDesC);
+ TBool found = GetStringFromConfig(aSection, KArgsKey(), cmdLineArgs);
+ aArgs.Copy(cmdLineArgs);
+ if (!found)
+ {
+ // Args may be seperated
+ TInt argNumber = 0;
+ TBuf<KTEFMaxNameLength> argKeyName;
+ found = ETrue;
+
+ while (found)
+ {
+ argNumber++;
+ argKeyName.Copy(KArgsKey());
+ argKeyName.AppendFormat(KInt(), argNumber);
+ found = GetStringFromConfig(aSection, argKeyName, cmdLineArgs);
+ if (found)
+ {
+ if (argNumber > 1)
+ {
+ aArgs.Append(KSpace());
+ }
+ aArgs.Append(cmdLineArgs);
+ }
+ }
+
+ if (argNumber > 1)
+ {
+ found = ETrue;
+ }
+ }
+ if (found)
+ {
+ INFO_PRINTF2(_L("Found args \"%S\" in INI file"), &aArgs);
+ }
+ return found;
+ }
+
+TBool CTraceCoreDataWrapper::GetLongStringFromConfig(const TTEFSectionName& aSection, const TDesC& aKeyName, TDes& aResult)
+ {
+ TPtrC stringLine;
+ TBool found = GetStringFromConfig(aSection, aKeyName, stringLine);
+ if (found)
+ {
+ aResult.Copy(stringLine);
+ }
+ else
+ {
+ TInt lineNumber = 0;
+ TBuf<KTEFMaxNameLength> keyName;
+ found = ETrue;
+ aResult.Zero();
+
+ while (found)
+ {
+ lineNumber++;
+ keyName.Copy(aKeyName);
+ keyName.AppendFormat(KInt(), lineNumber);
+ found = GetStringFromConfig(aSection, keyName, stringLine);
+ if (found)
+ {
+ aResult.Append(stringLine);
+ }
+ }
+
+ if (lineNumber > 1)
+ {
+ found = ETrue;
+ }
+ }
+ return found;
+ }
+
+TBool CTraceCoreDataWrapper::DoCommandL(const TTEFFunction& aCommand,
+ const TTEFSectionName& aSection,
+ const TInt aAsyncErrorIndex)
+ {
+ TBool ret = ETrue;
+ if (aCommand == KCmdCopyFile())
+ {
+ DoCmdCopyFileL(aSection);
+ }
+ else if (aCommand == KCmdDeleteFile())
+ {
+ DoCmdDeleteFileL(aSection);
+ }
+ else if (aCommand == KCmdDeleteFileFromAllDrives())
+ {
+ DoCmdDeleteFileFromAllDrivesL(aSection);
+ }
+ else if (aCommand == KCmdDeleteEmptyFolder())
+ {
+ DoCmdDeleteEmptyFolder(aSection);
+ }
+ else if (aCommand == KCmdFileExists())
+ {
+ DoCmdFileExists(aSection);
+ }
+ else if (aCommand == KCmdCheckFileSize())
+ {
+ DoCmdCheckFileSize(aSection);
+ }
+ else if (aCommand == KCmdRunProcess())
+ {
+ DoCmdRunProcess(aSection);
+ }
+ else if (aCommand == KCmdCreateSubstDrive())
+ {
+ DoCmdCreateSubstDrive(aSection);
+ }
+ else if (aCommand == KCmdUnSubstDrive())
+ {
+ DoCmdUnSubstDrive(aSection);
+ }
+ else if (aCommand == KCmdCheckMaxFileSize())
+ {
+ DoCmdCheckMaxFileSizeL(aSection);
+ }
+ else if (aCommand == KCmdCheckFileIsAppended())
+ {
+ DoCmdCheckFileIsAppendedL(aSection);
+ }
+ else if (aCommand == KCmdVerifyTraceData())
+ {
+ DoCmdVerifyTraceDataL(aSection);
+ }
+ else if (aCommand == KCmdVerifyPrimingData())
+ {
+ DoCmdVerifyPrimingDataL(aSection);
+ }
+ else if (aCommand == KCmdVerifyDroppedTraces())
+ {
+ DoCmdVerifyDroppedTracesL(aSection);
+ }
+ else if (aCommand == KCmdVerifySlot())
+ {
+ DoCmdVerifySlot(aSection);
+ }
+ else if (aCommand == KCmdFileChangeNotification())
+ {
+ DoCmdFileChangeNotification(aSection, aAsyncErrorIndex);
+ }
+ else if (aCommand == KCmdSetUpTraceOnActivation())
+ {
+ DoCmdSetUpTraceOnActivation(aSection);
+ }
+ else if (aCommand == KCmdRegisterNotifReceiver())
+ {
+ DoCmdRegisterNotifReceiver(aSection);
+ }
+ else if (aCommand == KCmdUnregisterNotifReceiver())
+ {
+ DoCmdUnregisterNotifReceiver(aSection);
+ }
+ else if (aCommand == KCmdCleanUpTraceOnActivation())
+ {
+ DoCmdCleanUpTraceOnActivation(aSection);
+ }
+ else if (aCommand == KCmdInstrumentTraceSequence())
+ {
+ DoCmdInstrumentTraceSequence(aSection);
+ }
+ else if (aCommand == KCmdSetUpTcLdd())
+ {
+ DoCmdSetUpTcLdd(aSection);
+ }
+ else if (aCommand == KCmdCleanUpTcLdd())
+ {
+ DoCmdCleanUpTcLdd(aSection);
+ }
+ else if (aCommand == KCmdSetUpTcOstLdd())
+ {
+ DoCmdSetUpTcOstLdd(aSection);
+ }
+ else if (aCommand == KCmdCleanUpTcOstLdd())
+ {
+ DoCmdCleanUpTcOstLdd(aSection);
+ }
+ else if (aCommand == KCmdActivateDeactivateTrace())
+ {
+ DoCmdActivateDeactivateTrace(aSection);
+ }
+ else if (aCommand == KCmdReadTracesFromBuffer())
+ {
+ DoCmdReadTracesFromBuffer();
+ }
+ else
+ {
+ ret = EFalse;
+ }
+ return ret;
+ }
+
+void CTraceCoreDataWrapper::CopyFileL(const TDesC& aSrcFile,
+ const TDesC& aDstFile)
+ {
+ INFO_PRINTF3(_L("CopyFile aSrcFile (%S) aDestFile (%S)"), &aSrcFile, &aDstFile);
+
+ TInt err = KErrNone;
+
+ // attempt to create the folder if it does not exist
+ if (!BaflUtils::FolderExists(iFs, aDstFile))
+ {
+ err = iFs.MkDirAll(aDstFile);
+ if (err != KErrNone)
+ {
+ ERR_PRINTF3(_L("CopyFile MKDIRALL FAILED aDestFile (%S) err (%d)"), &aDstFile, err);
+ SetError(err);
+ }
+ }
+
+ CFileMan* fileMan = CFileMan::NewL(iFs);
+
+ // Make file read-write
+ err = fileMan->Attribs(aDstFile, 0, KEntryAttReadOnly, TTime(0), CFileMan::ERecurse);
+ if (err != KErrNone && err != KErrNotFound)
+ {
+ ERR_PRINTF3(_L("CopyFile ATTRIBS FAILED aDestFile (%S) err (%d)"), &aDstFile, err);
+ SetError(err);
+ }
+
+ err = fileMan->Copy(aSrcFile, aDstFile);
+ if (err != KErrNone)
+ {
+ ERR_PRINTF4(_L("CopyFile COPY FAILED aSrcFile (%S) aDestFile (%S) err (%d)"), &aSrcFile, &aDstFile, err);
+ SetError(err);
+ }
+ else
+ {
+ INFO_PRINTF3(_L("CopyFile copied file OK aSrcFile (%S) aDestFile (%S)"), &aSrcFile, &aDstFile);
+ }
+
+ delete fileMan;
+ }
+
+void CTraceCoreDataWrapper::DeleteFileFromAllDrivesL(const TDesC& aFile)
+ {
+ INFO_PRINTF2(_L("DeleteFileFromAllDrives aFile (%S)"), &aFile);
+
+ TDriveList driveList;
+ TInt err = iFs.DriveList(driveList);
+ if (err != KErrNone)
+ {
+ ERR_PRINTF2(_L("DeleteFileFromAllDrives DRIVELIST FAILED err (%d)"), err);
+ SetError(err);
+ }
+ else
+ {
+ CFileMan* fileMan = CFileMan::NewL(iFs);
+ TChar drives[] = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
+ for (TInt i=0; i<driveList.Size(); i++)
+ {
+ if (driveList[i])
+ {
+ TFileName file;
+ file.Zero();
+ file.Append(drives[i]);
+ file.Append(_L(":"));
+ file.Append(aFile);
+
+ DeleteFileL(file, EFalse);
+ }
+ }
+ delete fileMan;
+ }
+ }
+
+void CTraceCoreDataWrapper::DeleteFileL(const TDesC& aFile, TInt aStrictMode)
+ {
+ if (aStrictMode)
+ {
+ INFO_PRINTF2(_L("DeleteFile aFile (%S)"), &aFile);
+ }
+
+ CFileMan* fileMan = CFileMan::NewL(iFs);
+
+ // Make file read-write
+ TInt err = fileMan->Attribs(aFile, 0, KEntryAttReadOnly, TTime(0), CFileMan::ERecurse);
+ if (err == KErrNone)
+ {
+ err = fileMan->Delete(aFile);
+ if (err == KErrNone)
+ {
+ INFO_PRINTF2(_L("DeleteFile deleted file OK file (%S)"), &aFile);
+ }
+ else
+ {
+ ERR_PRINTF3(_L("DeleteFile DELETE FAILED file (%S) err (%d)"), &aFile, err);
+ SetError(err);
+ }
+ }
+ else if (err == KErrAccessDenied && !aStrictMode)
+ {
+ WARN_PRINTF2(_L("DeleteFile file (%S) READONLY"), &aFile);
+ }
+ else if (err == KErrNotReady && !aStrictMode)
+ {
+ WARN_PRINTF2(_L("DeleteFile file (%S) NOT READY"), &aFile);
+ }
+ else if (err != KErrNotFound && err != KErrPathNotFound)
+ {
+ ERR_PRINTF3(_L("DeleteFile ATTRIBS error (%d) file (%S)"), err, &aFile);
+ SetError(err);
+ }
+ else if (aStrictMode)
+ {
+ INFO_PRINTF2(_L("DeleteFile aFile (%S) DOES NOT EXIST"), &aFile);
+ }
+
+ delete fileMan;
+ }
+
+/**
+ * Deletes an empty folder. If folder is not empty the current test is failed with KErrInUse
+ */
+void CTraceCoreDataWrapper::DeleteEmptyFolder(const TDesC& aFolder)
+ {
+ INFO_PRINTF2(_L("DeleteEmptyFolder aFolder (%S)"), &aFolder);
+
+ if (BaflUtils::PathExists(iFs, aFolder))
+ {
+ TInt err = iFs.SetAtt(aFolder, 0, KEntryAttReadOnly);
+ if (err != KErrNone)
+ {
+ ERR_PRINTF3(_L("DeleteEmptyFolder SETATT FAILED aFolder (%S) err (%d)"), &aFolder, err);
+ SetError(err);
+ }
+ else
+ {
+ err = iFs.RmDir(aFolder);
+ if (err != KErrNone)
+ {
+ ERR_PRINTF3(_L("DeleteEmptyFolder DELETE FAILED aFolder (%S) err (%d)"), &aFolder, err);
+ SetError(err);
+ }
+ else
+ {
+ INFO_PRINTF2(_L("DeleteEmptyFolder deleted folder OK aFolder (%S)"), &aFolder);
+ }
+ }
+ }
+ else
+ {
+ INFO_PRINTF2(_L("DeleteEmptyFolder aFolder DOES NOT EXIST (%S)"), &aFolder);
+ }
+ }
+
+TBool CTraceCoreDataWrapper::FileExists(const TDesC& aFile)
+ {
+ INFO_PRINTF2(_L("FileExists aFile (%S)"), &aFile);
+ TBool fileExists = EFalse;
+
+ if (BaflUtils::FileExists(iFs, aFile))
+ {
+ INFO_PRINTF2(_L("FileExists file exists OK aFile (%S)"), &aFile);
+ fileExists = ETrue;
+ }
+ else
+ {
+ ERR_PRINTF2(_L("FileExists aFile DOES NOT EXIST (%S)"), &aFile);
+ SetError(KErrNotFound);
+ }
+
+ return fileExists;
+ }
+
+/**
+ * Checks that a given file has size within given limits
+ *
+ * @return Size of file on success otherwise symbian error code
+ *
+ */
+TInt CTraceCoreDataWrapper::CheckFileSize(const TDesC& aFile, TInt aMinSize, TInt aMaxSize)
+ {
+ INFO_PRINTF2(_L("CheckFileSize aFile (%S)"), &aFile);
+ TInt result = KErrNotFound;
+
+ if (FileExists(aFile))
+ {
+ TEntry entry;
+ result = iFs.Entry(aFile, entry);
+ if (result != KErrNone)
+ {
+ ERR_PRINTF3(_L("CheckFileSize ENTRY FAILED aFile (%S) err (%d)"), &aFile, result);
+ }
+ else
+ {
+ TInt fileSize = entry.iSize;
+ INFO_PRINTF3(_L("CheckFileSize aFile (%S) fileSize (%d)"), &aFile, fileSize);
+ if ( (aMinSize == -1) && (aMaxSize == -1) )
+ {
+ ERR_PRINTF2(_L("CheckFileSize failed - need to specify max and / or min"), result);
+ result = KErrArgument;
+ }
+ else if ( (aMinSize == -1 || fileSize >= aMinSize) &&
+ (aMaxSize == -1 || fileSize <= aMaxSize) )
+ {
+ INFO_PRINTF3(_L("CheckFileSize file size OK aFile (%S) fileSize (%d)"), &aFile, fileSize);
+ result = fileSize;
+ }
+ else
+ {
+ ERR_PRINTF3(_L("CheckFileSize FAILED aFile (%S) fileSize (%d)"), &aFile, fileSize);
+ result = KErrGeneral;
+ }
+ }
+ }
+
+ if (result < 0)
+ {
+ SetError(result);
+ }
+
+ return result;
+ }
+
+void CTraceCoreDataWrapper::RunProcess(const TDesC& aProgramName, const TDesC& aCmdLineArgs, TInt aNoOfCalls, TInt aAllowedErrorCode)
+ {
+ for (TInt i=0; i<aNoOfCalls; i++)
+ {
+ TProcessCreatorResults res = CProcessCreator::StartProgram(aProgramName, aCmdLineArgs);
+ if (res.iCode == KErrNone || res.iCode == aAllowedErrorCode)
+ {
+ INFO_PRINTF7(_L("\"%S %S\" executes with code: %d, exitType: %d, desc: \"%S\" on call number %d"), &aProgramName, &aCmdLineArgs, res.iCode, res.iExitType, &(res.iDesc), i+1);
+ }
+ else
+ {
+ ERR_PRINTF7(_L("\"%S %S\" executes with code: %d, exitType: %d, desc: \"%S\" on call number %d"), &aProgramName, &aCmdLineArgs, res.iCode, res.iExitType, &(res.iDesc), i+1);
+ SetError(res.iCode);
+ }
+ }
+ }
+
+void CTraceCoreDataWrapper::CreateSubstDrive(const TDesC& aFolderPath, TDriveNumber aDrive)
+ {
+ TInt err = KErrNone;
+
+ // attempt to create the folder if it does not exist
+ if (!BaflUtils::FolderExists(iFs, aFolderPath))
+ {
+ err = iFs.MkDirAll(aFolderPath);
+ if (err != KErrNone)
+ {
+ ERR_PRINTF3(_L("CreateSubstDrive MKDIRALL FAILED aFile (%S) err (%d)"), &aFolderPath, err);
+ SetError(err);
+ }
+ }
+
+ if (err == KErrNone)
+ {
+ err = iFs.SetSubst(aFolderPath, aDrive);
+ if (err != KErrNone)
+ {
+ ERR_PRINTF4(_L("CreateSubstDrive SETSUBST FAILED aFolderPath (%S) aDrive (%d) err (%d)"), &aFolderPath, aDrive, err);
+ SetError(err);
+ }
+ else
+ {
+ INFO_PRINTF3(_L("CreateSubstDrive substed drive OK aFolderPath (%S) aDrive (%d)"), &aFolderPath, aDrive);
+ }
+ }
+ }
+
+void CTraceCoreDataWrapper::UnSubstDrive(TDriveNumber aDrive)
+ {
+ TInt err = iFs.SetSubst(KNullDesC, aDrive);
+ if (err != KErrNone)
+ {
+ ERR_PRINTF3(_L("UnSubstDrive SETSUBST FAILED aDrive (%d) err (%d)"), aDrive, err);
+ SetError(err);
+ }
+ else
+ {
+ INFO_PRINTF2(_L("UnSubstDrive unsubsted drive OK aDrive (%d)"), aDrive);
+ }
+ }
+
+
+// Macro for matching drive letter
+#define DRIVE_CONDITION(aDrv) if (aDriveString == _L(#aDrv)) { aDriveNumber = EDrive##aDrv; found = ETrue; }
+
+TBool CTraceCoreDataWrapper::DriveNumberFromString(const TDesC& aDriveString, TDriveNumber& aDriveNumber)
+ {
+ TBool found = EFalse;
+
+ DRIVE_CONDITION(A)
+ DRIVE_CONDITION(B)
+ DRIVE_CONDITION(C)
+ DRIVE_CONDITION(D)
+ DRIVE_CONDITION(E)
+ DRIVE_CONDITION(F)
+ DRIVE_CONDITION(G)
+ DRIVE_CONDITION(H)
+ DRIVE_CONDITION(I)
+ DRIVE_CONDITION(J)
+ DRIVE_CONDITION(K)
+ DRIVE_CONDITION(L)
+ DRIVE_CONDITION(M)
+ DRIVE_CONDITION(N)
+ DRIVE_CONDITION(O)
+ DRIVE_CONDITION(P)
+ DRIVE_CONDITION(Q)
+ DRIVE_CONDITION(R)
+ DRIVE_CONDITION(S)
+ DRIVE_CONDITION(T)
+ DRIVE_CONDITION(U)
+ DRIVE_CONDITION(V)
+ DRIVE_CONDITION(W)
+ DRIVE_CONDITION(X)
+ DRIVE_CONDITION(Y)
+ DRIVE_CONDITION(Z)
+
+ return found;
+ }
+
+void CTraceCoreDataWrapper::DoCmdCopyFileL(const TTEFSectionName& aSection)
+ {
+ TPtrC srcFile;
+ if (GetStringFromConfig(aSection, KSrcFileKey(), srcFile))
+ {
+ TFileName dstFile;
+ if (GetPathFromConfig(aSection, KDstFileKey(), dstFile))
+ {
+ CopyFileL(srcFile, dstFile);
+ }
+ }
+ else
+ {
+ ERR_PRINTF2(_L("No %S in INI file"), &KSrcFileKey());
+ SetBlockResult(EFail);
+ }
+ }
+
+void CTraceCoreDataWrapper::DoCmdDeleteFileFromAllDrivesL(const TTEFSectionName& aSection)
+ {
+ TFileName file;
+ if (GetPathFromConfig(aSection, KFileKey(), file))
+ {
+ DeleteFileFromAllDrivesL(file);
+ }
+ }
+
+void CTraceCoreDataWrapper::DoCmdDeleteFileL(const TTEFSectionName& aSection)
+ {
+ TFileName file;
+ if (GetPathFromConfig(aSection, KFileKey(), file))
+ {
+ DeleteFileL(file);
+ }
+ }
+
+void CTraceCoreDataWrapper::DoCmdDeleteEmptyFolder(const TTEFSectionName& aSection)
+ {
+ TFileName folder;
+ if (GetPathFromConfig(aSection, KFolderPathKey(), folder))
+ {
+ DeleteEmptyFolder(folder);
+ }
+ }
+
+void CTraceCoreDataWrapper::DoCmdFileExists(const TTEFSectionName& aSection)
+ {
+ TFileName file;
+ if (GetPathFromConfig(aSection, KFileKey(), file))
+ {
+ FileExists(file);
+ }
+ }
+
+void CTraceCoreDataWrapper::DoCmdCheckFileSize(const TTEFSectionName& aSection)
+ {
+ TFileName file;
+ if (GetPathFromConfig(aSection, KFileKey(), file))
+ {
+ TInt minSize = -1;
+ TInt maxSize = -1;
+ TInt size = -1;
+ if (GetIntFromConfig(aSection, KSizeKey(), size))
+ {
+ minSize = size;
+ maxSize = size;
+ }
+ else
+ {
+ GetIntFromConfig(aSection, KMinSizeKey(), minSize);
+ GetIntFromConfig(aSection, KMaxSizeKey(), maxSize);
+ }
+ TInt fileSize = CheckFileSize(file, minSize, maxSize);
+
+ // Store number in slot for future use, if slot number is given
+ TInt slotNumber;
+ if (GetIntFromConfig(aSection, KSlotNumberKey(), slotNumber))
+ {
+ StoreInSlot(fileSize, slotNumber);
+ }
+ }
+ }
+
+void CTraceCoreDataWrapper::DoCmdRunProcess(const TTEFSectionName& aSection)
+ {
+ TPtrC programName;
+ if (GetStringFromConfig(aSection, KExeNameKey(), programName))
+ {
+ TBuf<KTEFMaxNameLength> cmdLineArgs;
+ GetArgsFromConfig(aSection, cmdLineArgs);
+ TInt noOfCalls = 1;
+ GetIntFromConfig(aSection, KNoOfCallsKey(), noOfCalls);
+ TInt allowedErrorCode = KErrNone;
+ GetIntFromConfig(aSection, KAllowErrorKey(), allowedErrorCode);
+ RunProcess(programName, cmdLineArgs, noOfCalls, allowedErrorCode);
+ }
+ else
+ {
+ ERR_PRINTF2(_L("No %S in INI file"), &KExeNameKey());
+ SetBlockResult(EFail);
+ }
+ }
+
+void CTraceCoreDataWrapper::DoCmdCreateSubstDrive(const TTEFSectionName& aSection)
+ {
+ TPtrC folderPath;
+ if (GetStringFromConfig(aSection, KFolderPathKey(), folderPath))
+ {
+ TPtrC driveString;
+ if (GetStringFromConfig(aSection, KDriveKey(), driveString))
+ {
+ TDriveNumber driveNumber;
+ if (DriveNumberFromString(driveString, driveNumber))
+ {
+ CreateSubstDrive(folderPath, driveNumber);
+ }
+ else
+ {
+ ERR_PRINTF2(_L("Could not parse drive %S in INI file"), &driveString);
+ SetBlockResult(EFail);
+ }
+ }
+ else
+ {
+ ERR_PRINTF2(_L("No %S in INI file"), &KDriveKey());
+ SetBlockResult(EFail);
+ }
+ }
+ else
+ {
+ ERR_PRINTF2(_L("No %S in INI file"), &KFolderPathKey());
+ SetBlockResult(EFail);
+ }
+ }
+
+void CTraceCoreDataWrapper::DoCmdUnSubstDrive(const TTEFSectionName& aSection)
+ {
+ TPtrC driveString;
+ if (GetStringFromConfig(aSection, KDriveKey(), driveString))
+ {
+ TDriveNumber driveNumber;
+ if (DriveNumberFromString(driveString, driveNumber))
+ {
+ UnSubstDrive(driveNumber);
+ }
+ else
+ {
+ ERR_PRINTF2(_L("Could not parse drive %S in INI file"), &driveString);
+ SetBlockResult(EFail);
+ }
+ }
+ else
+ {
+ ERR_PRINTF2(_L("No %S in INI file"), &KDriveKey());
+ SetBlockResult(EFail);
+ }
+ }
+
+/**
+ * Test command to verify the max file size of output file
+ *
+ * Tracing needs to be started for this command to complete
+ *
+ */
+void CTraceCoreDataWrapper::DoCmdCheckMaxFileSizeL(const TTEFSectionName& aSection)
+ {
+ TFileName file;
+ TInt maxSize;
+ TPtrC programName;
+ // Get all required parameters from INI file
+ if ( GetPathFromConfig(aSection, KFileKey(), file) &&
+ GetIntFromConfig(aSection, KMaxSizeKey(), maxSize) &&
+ GetStringFromConfig(aSection, KExeNameKey(), programName) )
+ {
+ // Get optional params from INI file
+ TBool unfetteredSize = EFalse;
+ GetBoolFromConfig(aSection, KUnfetteredKey(), unfetteredSize);
+ TBuf<KTEFMaxNameLength> cmdLineArgs;
+ GetArgsFromConfig(aSection, cmdLineArgs);
+ TInt noOfCalls = 1;
+ GetIntFromConfig(aSection, KNoOfCallsKey(), noOfCalls);
+ TInt minSize = 0;
+ if (!unfetteredSize)
+ {
+ GetIntFromConfig(aSection, KMinSizeKey(), minSize);
+ }
+
+ // Number of seconds to perform test for (for unfettered case)
+ TBool useTimer = EFalse;
+ RTimer timer;
+ TRequestStatus timerStatus(KRequestPending);
+ TInt duration;
+ if (unfetteredSize && GetIntFromConfig(aSection, KDurationKey(), duration))
+ {
+ TInt err = timer.CreateLocal();
+ CleanupClosePushL(timer);
+ if (err == KErrNone)
+ {
+ useTimer = ETrue;
+ INFO_PRINTF2(_L("Running timer for %d seconds"), duration);
+ timer.After(timerStatus, duration * KSecondsToMicroSeconds);
+ }
+ else
+ {
+ ERR_PRINTF2(_L("Error in creating timer %d"), err);
+ SetBlockResult(EFail);
+ }
+ }
+
+ // Keep calling an EXE so that trace data is appended to output file
+ // Tracing must be started and the EXE must generate trace data for the config file used
+ TBool finished = EFalse;
+ TInt lastFileSize = 0;
+ TInt currentFileSize = 0;
+ while (!finished)
+ {
+ // Call the EXE
+ RunProcess(programName, cmdLineArgs, noOfCalls);
+ if (unfetteredSize)
+ {
+ // Get the size of output file
+ currentFileSize = CheckFileSize(file, 0, -1);
+ }
+ else
+ {
+ // Check the size of output file is smaller than max file size
+ currentFileSize = CheckFileSize(file, 0, maxSize);
+ }
+ if (currentFileSize < 0)
+ {
+ // An error has occurred in checking the file size. Stop and fail the test
+ ERR_PRINTF2(_L("Error in file size %d"), currentFileSize);
+ SetBlockResult(EFail);
+ finished = ETrue;
+ }
+ else if (currentFileSize < lastFileSize)
+ {
+ // Output file size has decreased rather than increased. Stop and fail the test
+ ERR_PRINTF2(_L("File size (%d) has decreased rather than increased"), currentFileSize);
+ SetBlockResult(EFail);
+ finished = ETrue;
+ }
+ else if (unfetteredSize)
+ {
+ if (currentFileSize > maxSize)
+ {
+ // File size got to required size. Test has passed.
+ INFO_PRINTF1(_L("File size checking completed successfully"));
+ finished = ETrue;
+ }
+ else if (currentFileSize == lastFileSize)
+ {
+ // File size has not increased. Print a warning and continue
+ WARN_PRINTF2(_L("File size (%d) has not increased"), currentFileSize);
+ }
+ }
+ else if (currentFileSize == lastFileSize)
+ {
+ if (currentFileSize < minSize)
+ {
+ // File size has not reached required minimum. Stop and fail the test
+ ERR_PRINTF3(_L("File size (%d) has not met the minimum required (%d)"), currentFileSize, minSize);
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ // File size got to minimum required and has stopped increasing, staying below required max size. Test has passed.
+ INFO_PRINTF1(_L("File size checking completed successfully"));
+ }
+ finished = ETrue;
+ }
+ lastFileSize = currentFileSize;
+ if (useTimer && timerStatus == KErrNone)
+ {
+ // File size has been increasing for required number of seconds. Test has passed.
+ INFO_PRINTF2(_L("File size checking completed successfully after %d seconds"), duration);
+ finished = ETrue;
+ }
+ }
+ if (useTimer)
+ {
+ timer.Cancel();
+ CleanupStack::PopAndDestroy(&timer);
+ }
+ }
+ else
+ {
+ ERR_PRINTF3(_L("Need %S and %S in INI file"), &KMaxSizeKey(), &KExeNameKey());
+ SetBlockResult(EFail);
+ }
+ }
+
+/**
+ * Test command to verify the output file is appended to and not overwritten
+ *
+ * Tracing needs to be started for this command to complete and
+ * an output file containing some data must exist
+ *
+ */
+void CTraceCoreDataWrapper::DoCmdCheckFileIsAppendedL(const TTEFSectionName& aSection)
+ {
+ TFileName file;
+ TPtrC programName;
+ TInt maxSize;
+ TInt duration;
+ // Get all required parameters from INI file
+ if ( GetPathFromConfig(aSection, KFileKey(), file) &&
+ GetIntFromConfig(aSection, KMaxSizeKey(), maxSize) &&
+ GetIntFromConfig(aSection, KDurationKey(), duration) &&
+ GetStringFromConfig(aSection, KExeNameKey(), programName) )
+ {
+ // Get optional params from INI file
+ TBuf<KTEFMaxNameLength> cmdLineArgs;
+ GetArgsFromConfig(aSection, cmdLineArgs);
+ TInt noOfCalls = 1;
+ GetIntFromConfig(aSection, KNoOfCallsKey(), noOfCalls);
+ TInt minSize = 1;
+ GetIntFromConfig(aSection, KMinSizeKey(), minSize);
+ TInt noOfAllowedTimeouts = 0;
+ GetIntFromConfig(aSection, KNoOfAllowedTimeoutsKey(), noOfAllowedTimeouts);
+ TInt minIncrease = 0;
+ GetIntFromConfig(aSection, KMinIncreaseKey(), minIncrease);
+
+ // Create timer for time-outs
+ RTimer timer;
+ TInt err = timer.CreateLocal();
+ CleanupClosePushL(timer);
+ if (err != KErrNone)
+ {
+ ERR_PRINTF2(_L("Create timer error %d"), err);
+ SetBlockResult(EFail);
+ }
+
+ // Keep calling an EXE so that trace data is created in output file
+ // Tracing must be started and the EXE must generate trace data for the config file used
+ // The output file must exist and already contain some data
+ // Get current size of output file, and check it is non-zero or min provided
+ TInt originalFileSize = CheckFileSize(file, minSize, -1);
+ if (originalFileSize < 0)
+ {
+ // An error has occurred in checking the file size. Stop and fail the test
+ ERR_PRINTF2(_L("Error in file size %d"), originalFileSize);
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ TInt currentFileSize = 0;
+ TInt noOfTimeouts = 0;
+ while (currentFileSize < maxSize)
+ {
+ TRequestStatus notifyStatus(KRequestPending);
+ TRequestStatus timerStatus(KRequestPending);
+ // Start timeout timer
+ timer.After(timerStatus, duration * KSecondsToMicroSeconds);
+ // Request notification of file change
+ iFs.NotifyChange(ENotifyAll, notifyStatus, file);
+
+ // Call the EXE
+ RunProcess(programName, cmdLineArgs, noOfCalls);
+
+ // Wait for file to update or timeout
+ User::WaitForRequest(notifyStatus, timerStatus);
+
+ if (timerStatus == KErrNone)
+ {
+ // We have timed out
+ noOfTimeouts++;
+ WARN_PRINTF3(_L("Have not received notification of file change in %d seconds (%d tries remaining)"), duration, noOfAllowedTimeouts-noOfTimeouts+1);
+ }
+ else
+ {
+ // Cancel timer
+ timer.Cancel();
+ }
+
+ if (notifyStatus == KErrNone)
+ {
+ // We have received file change notification
+ INFO_PRINTF2(_L("Have received notification of file change (%S)"), &file);
+ }
+ else
+ {
+ // Cancel file change notification
+ iFs.NotifyChangeCancel();
+ }
+
+ // We get a timeout when output file is not updated and so there are dropped traces.
+ // This test is only checking append functionality so we allow this for a user-defined number of times.
+ if (noOfTimeouts > noOfAllowedTimeouts)
+ {
+ // We have timed out too many times, so fail the test
+ ERR_PRINTF2(_L("File has not been updated %d times"), noOfTimeouts);
+ SetBlockResult(EFail);
+ break;
+ }
+
+ // Check the size of output file is expected size
+ currentFileSize = CheckFileSize(file, originalFileSize + minIncrease, -1);
+ if (currentFileSize < 0)
+ {
+ // An error has occurred in checking the file size. Stop and fail the test
+ ERR_PRINTF2(_L("Error in file size %d"), currentFileSize);
+ SetBlockResult(EFail);
+ break;
+ }
+ originalFileSize = currentFileSize;
+ }
+ }
+ CleanupStack::PopAndDestroy(&timer); // close timer
+ }
+ else
+ {
+ ERR_PRINTF4(_L("Need %S, %S and %S in INI file"), &KMaxSizeKey(), &KExeNameKey(), &KDurationKey());
+ SetBlockResult(EFail);
+ }
+ }
+
+/**
+ * Test command to verify the trace buffer contains the expected number of given printf traces
+ */
+void CTraceCoreDataWrapper::DoCmdVerifyTraceDataL(const TTEFSectionName& aSection)
+ {
+ TBuf<KLongStringLength> findString;
+ // Get all required parameters from INI file
+ if (GetLongStringFromConfig(aSection, KFindStringKey(), findString))
+ {
+ TInt expectedNumFound = 1;
+ GetIntFromConfig(aSection, KExpectedKey(), expectedNumFound);
+ TInt numFound = 0;
+ BufferHasPrintfStringL(iTraceBuffer, findString, numFound);
+ if (numFound != expectedNumFound)
+ {
+ ERR_PRINTF3(_L("Expected printf %d times, found it %d times"), expectedNumFound, numFound);
+ if (numFound == 0)
+ {
+ SetError(KErrNotFound);
+ }
+ else
+ {
+ SetError(KErrGeneral);
+ }
+ }
+ }
+ else
+ {
+ ERR_PRINTF2(_L("Need %S in INI file"), &KFindStringKey());
+ SetBlockResult(EFail);
+ }
+ }
+
+/**
+ * Test command to verify the output file contains the expected number of traces / priming traces
+ * and optionally validates that the priming data contains the correct values
+ *
+ * This function gets the number of traces / priming traces and stores them in the required slots
+ * so the values can be verified later
+ */
+void CTraceCoreDataWrapper::DoCmdVerifyPrimingDataL(const TTEFSectionName& aSection)
+ {
+ TFileName filePath;
+ TInt groupId;
+ // Get all required parameters from INI file
+ if ( GetPathFromConfig(aSection, KFileKey(), filePath) &&
+ GetIntFromConfig(aSection, KGroupIdKey(), groupId) )
+ {
+ // Get optional params from INI file
+ TBool verifyData = EFalse;
+ GetBoolFromConfig(aSection, KVerifyData(), verifyData);
+
+ TInt numTraces = 0;
+ TInt numPrimingTraces = 0;
+ VerifyPrimingDataL(filePath, groupId, verifyData, numTraces, numPrimingTraces);
+
+ // Store numbers in slots for future use, if slot numbers are given
+ TInt slotNumber;
+ if (GetIntFromConfig(aSection, KTracesSlotNumberKey(), slotNumber))
+ {
+ StoreInSlot(numTraces, slotNumber);
+ }
+ if (GetIntFromConfig(aSection, KPrimingTracesSlotNumberKey(), slotNumber))
+ {
+ StoreInSlot(numPrimingTraces, slotNumber);
+ }
+ }
+ else
+ {
+ ERR_PRINTF2(_L("Need %S in INI file"), &KGroupIdKey());
+ SetBlockResult(EFail);
+ }
+ }
+
+/**
+ * This function gets the number of traces / priming traces from the data file given for the required GID
+ * It optionally validates that the priming data contains the correct values
+ */
+void CTraceCoreDataWrapper::VerifyPrimingDataL(const TDesC& aFile, TInt aGroupId, TBool aVerifyData, TInt& aNumTraces, TInt& aNumPrimingTraces)
+ {
+ INFO_PRINTF3(_L("VerifyPrimingData aFile (%S) aGroupId (%d)"), &aFile, aGroupId);
+
+ aNumTraces = 0;
+ aNumPrimingTraces = 0;
+
+ INFO_PRINTF3(_L("Calling TTraceDataParser::ParsePrimingDataL(%S, %d)"), &aFile, aGroupId);
+ TInt err = TTraceDataParser::ParsePrimingDataL(aFile, iFs, aGroupId, aNumPrimingTraces, aNumTraces, aVerifyData);
+ INFO_PRINTF3(_L("Number of traces for GID %d: %d"), aGroupId, aNumTraces);
+ INFO_PRINTF3(_L("Number of priming traces for GID %d: %d"), aGroupId, aNumPrimingTraces);
+ if (err != KErrNone)
+ {
+ ERR_PRINTF2(_L("ParsePrimingDataL() error %d"), err);
+ SetError(err);
+ }
+ }
+
+/**
+ * Test command to verify the output file contains the expected sequence of traces
+ * and checks that any dropped traces are correctly handled
+ */
+void CTraceCoreDataWrapper::DoCmdVerifyDroppedTracesL(const TTEFSectionName& aSection)
+ {
+ TFileName filePath;
+ // Get all required parameters from INI file
+ if (GetPathFromConfig(aSection, KFileKey(), filePath))
+ {
+ TInt lastNumberFound = 0;
+ TInt numDroppedTraces = 0;
+
+ TPtrC findString;
+ // Look to see if we have a string to fing
+ if (GetStringFromConfig(aSection, KFindStringKey(), findString))
+ {
+ VerifyDroppedPrintfTracesL(filePath, findString, lastNumberFound, numDroppedTraces);
+ }
+ else
+ {
+ TInt groupId = 0;
+ GetIntFromConfig(aSection, KGroupIdKey(), groupId);
+ TInt componentId = 0;
+ GetHexFromConfig(aSection, KComponentIdKey(), componentId);
+ VerifyDroppedBinaryTracesL(filePath, groupId, componentId, lastNumberFound, numDroppedTraces);
+ }
+
+ TInt expectedLastNumberFound;
+ if (GetIntFromConfig(aSection, KExpectedKey(), expectedLastNumberFound))
+ {
+ if (expectedLastNumberFound == lastNumberFound)
+ {
+ INFO_PRINTF2(_L("Last number found (%d) as expected"), lastNumberFound);
+ }
+ else
+ {
+ ERR_PRINTF3(_L("Last number found (%d) not as expected (%d)"), lastNumberFound, expectedLastNumberFound);
+ SetBlockResult(EFail);
+ }
+ }
+ }
+ }
+
+/**
+ * This function verifies the given file contains the expected sequence of printf traces
+ * and checks that any dropped traces are correctly handled
+ */
+void CTraceCoreDataWrapper::VerifyDroppedPrintfTracesL(const TDesC& aFile, const TDesC& aFindString, TInt& aLastNumberFound, TInt& aNumDroppedTraces)
+ {
+ INFO_PRINTF3(_L("VerifyDroppedPrintfTracesL aFile (%S) aFindString (%S)"), &aFile, &aFindString);
+
+ aLastNumberFound = 0;
+ aNumDroppedTraces = 0;
+
+ TBuf8<KTEFMaxNameLength> findString;
+ findString.Copy(aFindString);
+ INFO_PRINTF3(_L("Calling TTraceDataParser::DataHasTraceSequenceL(%S, \"%S\")"), &aFile, &aFindString);
+ TInt err = TTraceDataParser::DataHasTraceSequenceL(aFile, iFs, aLastNumberFound, aNumDroppedTraces, &findString);
+ INFO_PRINTF3(_L("Last number found is %d, (%d dropped traces)"), aLastNumberFound, aNumDroppedTraces);
+ if (err != KErrNone)
+ {
+ ERR_PRINTF2(_L("DataHasTraceSequenceL() error %d"), err);
+ SetError(err);
+ }
+ }
+
+/**
+ * This function verifies the given file contains the expected sequence of binary traces
+ * and checks that any dropped traces are correctly handled
+ */
+void CTraceCoreDataWrapper::VerifyDroppedBinaryTracesL(const TDesC& aFile, TInt aGroupId, TInt aComponentId, TInt& aLastNumberFound, TInt& aNumDroppedTraces)
+ {
+ INFO_PRINTF4(_L("VerifyDroppedBinaryTracesL aFile (%S) aGroupId (%d) aComponentId (0x%x)"), &aFile, aGroupId, aComponentId);
+
+ aLastNumberFound = 0;
+ aNumDroppedTraces = 0;
+
+ INFO_PRINTF4(_L("Calling TTraceDataParser::DataHasTraceSequenceL(%S, %d, 0x%x)"), &aFile, aGroupId, aComponentId);
+ TInt err = TTraceDataParser::DataHasTraceSequenceL(aFile, iFs, aLastNumberFound, aNumDroppedTraces, NULL, aGroupId, aComponentId);
+ INFO_PRINTF3(_L("Last number found is %d, (%d dropped traces)"), aLastNumberFound, aNumDroppedTraces);
+ if (err != KErrNone)
+ {
+ ERR_PRINTF2(_L("DataHasTraceSequenceL() error %d"), err);
+ SetError(err);
+ }
+ }
+
+/**
+ * This function checks if printf traces in the data file given contain a given string
+ */
+void CTraceCoreDataWrapper::FileHasPrintfStringL(const TDesC& aFile, const TDesC& aFindString, TInt& aNumFound)
+ {
+ INFO_PRINTF3(_L("FileHasPrintfStringL aFile (%S) aFindString (%S)"), &aFile, &aFindString);
+ aNumFound = 0;
+ TBuf8<KTEFMaxNameLength> findString;
+ findString.Copy(aFindString);
+ INFO_PRINTF3(_L("Calling TTraceDataParser::DataHasPrintfStringL(%S, \"%S\")"), &aFile, &aFindString);
+ TInt err = TTraceDataParser::DataHasPrintfStringL(aFile, iFs, findString, aNumFound);
+ INFO_PRINTF2(_L("Data in file contains string %d times"), aNumFound);
+ if (err != KErrNone)
+ {
+ ERR_PRINTF2(_L("DataHasPrintfString() error %d"), err);
+ SetError(err);
+ }
+ }
+
+/**
+ * This function checks if printf traces in the data buffer given contain a given string
+ */
+void CTraceCoreDataWrapper::BufferHasPrintfStringL(TDesC8& aBuffer, const TDesC& aFindString, TInt& aNumFound)
+ {
+ INFO_PRINTF2(_L("BufferHasPrintfStringL aFindString (%S)"), &aFindString);
+ aNumFound = 0;
+ TBuf8<KTEFMaxNameLength> findString;
+ findString.Copy(aFindString);
+ INFO_PRINTF2(_L("Calling TTraceDataParser::DataHasPrintfString(\"%S\")"), &aFindString);
+ TInt err = TTraceDataParser::DataHasPrintfString(aBuffer, findString, aNumFound);
+ INFO_PRINTF2(_L("Data in buffer contains string %d times"), aNumFound);
+ if (err != KErrNone)
+ {
+ ERR_PRINTF2(_L("DataHasPrintfString() error %d"), err);
+ SetError(err);
+ }
+ }
+
+TInt CTraceCoreDataWrapper::GetSlotValue(const TTEFSectionName& aSection, const TDesC& aValueKey, const TDesC& aSlotNumberKey)
+ {
+ TInt value = 0;
+ TInt slot;
+ if (GetIntFromConfig(aSection, aValueKey, value))
+ {
+ // Value given directly in INI file, so don't need slot number
+ if (GetIntFromConfig(aSection, aSlotNumberKey, slot))
+ {
+ ERR_PRINTF3(_L("Cannot have %S and %S in INI file"), &aValueKey, &aSlotNumberKey);
+ SetBlockResult(EFail);
+ }
+ }
+ else if (GetIntFromConfig(aSection, aSlotNumberKey, slot))
+ {
+ // Slot number given in INI file, so get value from it
+ value = ReadFromSlot(slot);
+ }
+ else
+ {
+ ERR_PRINTF3(_L("Need %S or %S in INI file"), &aValueKey, &aSlotNumberKey);
+ SetBlockResult(EFail);
+ }
+ return value;
+ }
+
+void CTraceCoreDataWrapper::DoCmdVerifySlot(const TTEFSectionName& aSection)
+ {
+ // Get values to compare
+ TInt valueA = GetSlotValue(aSection, KValueAKey(), KSlotANumberKey());
+ TInt valueB = GetSlotValue(aSection, KValueBKey(), KSlotBNumberKey());
+
+ // Compare the values
+ INFO_PRINTF3(_L("Comparing value A (%d) with value B (%d)"), valueA, valueB);
+
+ TInt difference = 0;
+ TInt minDifference = -1;
+ TInt maxDifference = -1;
+ if (GetIntFromConfig(aSection, KDifferenceKey(), difference))
+ {
+ if (difference != 0)
+ {
+ minDifference = difference;
+ maxDifference = difference;
+ }
+ }
+ else
+ {
+ GetIntFromConfig(aSection, KMinDifferenceKey(), minDifference);
+ GetIntFromConfig(aSection, KMaxDifferenceKey(), maxDifference);
+ }
+ if ( (minDifference == -1) && (maxDifference == -1) && (valueA != valueB) )
+ {
+ ERR_PRINTF1(_L("Values are not the same"));
+ SetBlockResult(EFail);
+ }
+ else if ( (minDifference != -1 && valueB - valueA < minDifference) ||
+ (maxDifference != -1 && valueB - valueA > maxDifference) )
+ {
+ ERR_PRINTF1(_L("Difference in values not in given range"));
+ SetBlockResult(EFail);
+ }
+ else
+ {
+ INFO_PRINTF1(_L("Slot value successfully verified"));
+ }
+ }
+
+void CTraceCoreDataWrapper::StoreInSlot(TInt aEntry, TInt aSlot)
+ {
+ if (aSlot >= 1 && aSlot <= iSlots.Count())
+ {
+ iSlots[aSlot-1] = aEntry;
+ INFO_PRINTF3(_L("Storing number %d in slot %d"), aEntry, aSlot);
+ }
+ else
+ {
+ ERR_PRINTF3(_L("Cannot store number in slot %d - not in range [1,%d]"), aSlot, iSlots.Count());
+ SetBlockResult(EFail);
+ }
+ }
+
+TInt CTraceCoreDataWrapper::ReadFromSlot(TInt aSlot)
+ {
+ TInt entry = 0;
+ if (aSlot >= 1 && aSlot <= iSlots.Count())
+ {
+ entry = iSlots[aSlot-1];
+ INFO_PRINTF3(_L("Reading number %d from slot %d"), entry, aSlot);
+ }
+ else
+ {
+ ERR_PRINTF3(_L("Cannot read number from slot %d - not in range [1,%d]"), aSlot, iSlots.Count());
+ SetBlockResult(EFail);
+ }
+ return entry;
+ }
+
+void CTraceCoreDataWrapper::DoCmdFileChangeNotification(const TTEFSectionName& aSection, const TInt aAsyncErrorIndex)
+ {
+ TFileName file;
+ TInt duration;
+ // Get all required parameters from INI file
+ if ( GetPathFromConfig(aSection, KFileKey(), file) &&
+ GetIntFromConfig(aSection, KDurationKey(), duration) )
+ {
+ INFO_PRINTF2(_L("Requesting file change notification for file %S"), &file);
+ // Request notification of file change
+ iFs.NotifyChange(ENotifyAll, iActiveFileChangeNotification->iStatus, file);
+ iActiveFileChangeNotification->Activate(aAsyncErrorIndex);
+ IncOutstanding();
+ // Start timeout timer
+ iTimer.After(iActiveFileChangeNotificationTimeout->iStatus, duration * KSecondsToMicroSeconds);
+ iActiveFileChangeNotificationTimeout->Activate(aAsyncErrorIndex);
+ IncOutstanding();
+ iCurrentSectionName.Set(aSection);
+ }
+ else
+ {
+ ERR_PRINTF2(_L("Need %S in INI file"), &KDurationKey());
+ SetBlockResult(EFail);
+ }
+ }
+
+void CTraceCoreDataWrapper::RunL(CActive* aActive, TInt aIndex)
+ {
+ if (aActive == iActiveFileChangeNotification)
+ {
+ TInt err = iActiveFileChangeNotification->iStatus.Int();
+ if (err == KErrNone)
+ {
+ INFO_PRINTF1(_L("Received file change notification"));
+ }
+ else
+ {
+ WARN_PRINTF2(_L("File change notification error %d"), err);
+ }
+
+ TBool fileReady = ETrue;
+ if (err != KErrNone)
+ {
+ fileReady = EFalse;
+ }
+ TPtrC findString;
+ // Look to see if we have a string to find
+ if (GetStringFromConfig(iCurrentSectionName, KFindStringKey(), findString))
+ {
+ fileReady = EFalse;
+ TFileName file;
+ if (GetPathFromConfig(iCurrentSectionName, KFileKey(), file))
+ {
+ // The file is ready if it contains the string given in the INI file
+ TInt expectedNumFound = 1;
+ GetIntFromConfig(iCurrentSectionName, KExpectedKey(), expectedNumFound);
+ TInt numFound = 0;
+ FileHasPrintfStringL(file, findString, numFound);
+ if (numFound == expectedNumFound)
+ {
+ fileReady = ETrue;
+ }
+ }
+ if (!fileReady && err == KErrNone)
+ {
+ // File isn't ready, so request notification again
+ // Keep doing this until file is ready or it times out
+ INFO_PRINTF2(_L("Requesting file change notification for file %S"), &file);
+ iFs.NotifyChange(ENotifyAll, iActiveFileChangeNotification->iStatus, file);
+ iActiveFileChangeNotification->Activate(aIndex);
+ IncOutstanding();
+ }
+ }
+ if (fileReady)
+ {
+ // Cancel file change notification timeout
+ iTimer.Cancel();
+ }
+ else if (err != KErrNone)
+ {
+ ERR_PRINTF2(_L("File change notification error %d"), err);
+ SetAsyncError(aIndex, err);
+ }
+ DecOutstanding();
+ }
+ else if (aActive == iActiveFileChangeNotificationTimeout)
+ {
+ TInt err = iActiveFileChangeNotificationTimeout->iStatus.Int();
+ if (err == KErrNone)
+ {
+ INFO_PRINTF1(_L("File change notification has timed out"));
+ // Cancel file change notification
+ iFs.NotifyChangeCancel();
+ }
+ else if (err != KErrCancel)
+ {
+ ERR_PRINTF2(_L("File change notification timeout error %d"), err);
+ SetAsyncError(aIndex, err);
+ }
+ DecOutstanding();
+ }
+ else
+ {
+ ERR_PRINTF1(_L("Stray signal"));
+ SetBlockResult(EFail);
+ }
+ }
+
+void CTraceCoreDataWrapper::DoCancel(CActive* aActive, TInt /*aIndex*/)
+ {
+ if (aActive == iActiveFileChangeNotification)
+ {
+ INFO_PRINTF1(_L("File change notification cancelled"));
+ }
+ else if (aActive == iActiveFileChangeNotificationTimeout)
+ {
+ INFO_PRINTF1(_L("File change notification timeout cancelled"));
+ }
+ else
+ {
+ ERR_PRINTF1(_L("Stray signal"));
+ SetBlockResult(EFail);
+ }
+ }
+
+void CTraceCoreDataWrapper::DoCmdRegisterNotifReceiver(const TTEFSectionName& aSection)
+ {
+ TInt groupId;
+ TInt componentId;
+ // Get all required parameters from INI file
+ if ( GetIntFromConfig(aSection, KGroupIdKey(), groupId) &&
+ GetHexFromConfig(aSection, KComponentIdKey(), componentId) )
+ {
+ TTraceOnActivationParams traceOnActivationParams;
+ traceOnActivationParams.iGroupId = groupId;
+ traceOnActivationParams.iComponentId = componentId;
+
+ TInt err = iTraceOnActivationLdd.RegisterNotificationReceiver(traceOnActivationParams);
+ if (err != KErrNone)
+ {
+ ERR_PRINTF4(_L("RegisterNotificationReceiver(%d,0x%x) error %d"), groupId, componentId, err);
+ SetError(err);
+ }
+ else
+ {
+ INFO_PRINTF3(_L("RegisterNotificationReceiver(%d,0x%x) returns no error"), groupId, componentId);
+ }
+ }
+ else
+ {
+ ERR_PRINTF3(_L("Need %S and %S in INI file"), &KGroupIdKey(), &KComponentIdKey());
+ SetBlockResult(EFail);
+ }
+ }
+
+void CTraceCoreDataWrapper::DoCmdUnregisterNotifReceiver(const TTEFSectionName& aSection)
+ {
+ TInt groupId;
+ TInt componentId;
+ // Get all required parameters from INI file
+ if ( GetIntFromConfig(aSection, KGroupIdKey(), groupId) &&
+ GetHexFromConfig(aSection, KComponentIdKey(), componentId) )
+ {
+ TTraceOnActivationParams traceOnActivationParams;
+ traceOnActivationParams.iGroupId = groupId;
+ traceOnActivationParams.iComponentId = componentId;
+
+ TInt err = iTraceOnActivationLdd.UnregisterNotificationReceiver(traceOnActivationParams);
+ if (err != KErrNone)
+ {
+ ERR_PRINTF4(_L("UnregisterNotificationReceiver(%d,0x%x) error %d"), groupId, componentId, err);
+ SetError(err);
+ }
+ else
+ {
+ INFO_PRINTF3(_L("UnregisterNotificationReceiver(%d,0x%x) returns no error"), groupId, componentId);
+ }
+ }
+ else
+ {
+ ERR_PRINTF3(_L("Need %S and %S in INI file"), &KGroupIdKey(), &KComponentIdKey());
+ SetBlockResult(EFail);
+ }
+ }
+
+void CTraceCoreDataWrapper::InstrumentBinaryTracePoint(TInt aGroupId, TInt aComponentId, TInt aData, TInt aTraceId)
+ {
+ TComponentId KOstTraceComponentID = aComponentId;
+ // Calculate trace word from Group ID
+ TUint32 traceWord = (aGroupId << GROUPIDSHIFT) | aTraceId;
+ OstTrace1(aGroupId, traceWord, "You will only see this text in Trace Viewer: %d", aData);
+ }
+
+void CTraceCoreDataWrapper::InstrumentBinaryTraceSequence(TInt aSequenceLength, TInt aGroupId, TInt aComponentId)
+ {
+ for (TInt i=1; i<=aSequenceLength; i++)
+ {
+ InstrumentBinaryTracePoint(aGroupId, aComponentId, i, i);
+ }
+ }
+
+void CTraceCoreDataWrapper::InstrumentPrintfTraceSequence(TInt aSequenceLength, const TDesC& aString)
+ {
+ INFO_PRINTF3(_L("InstrumentPrintfTraceSequence(%d, \"%S\""), aSequenceLength, &aString);
+ TBuf8<KTEFMaxNameLength> givenString;
+ givenString.Copy(aString);
+ for (TInt i=1; i<=aSequenceLength; i++)
+ {
+ TBuf8<KTEFMaxNameLength> formattedString;
+ formattedString.Format(givenString, i);
+ RDebug::Printf("%S", &formattedString);
+ }
+ }
+
+void CTraceCoreDataWrapper::DoCmdInstrumentTraceSequence(const TTEFSectionName& aSection)
+ {
+ TInt sequenceLength;
+ // Get all required parameters from INI file
+ if (GetIntFromConfig(aSection, KLengthKey(), sequenceLength))
+ {
+ TPtrC printfString;
+ if (GetStringFromConfig(aSection, KStringKey(), printfString))
+ {
+ InstrumentPrintfTraceSequence(sequenceLength, printfString);
+ }
+ else
+ {
+ TInt groupId = 0;
+ GetIntFromConfig(aSection, KGroupIdKey(), groupId);
+ TInt componentId = 0;
+ GetHexFromConfig(aSection, KComponentIdKey(), componentId);
+ InstrumentBinaryTraceSequence(sequenceLength, groupId, componentId);
+ }
+ }
+ else
+ {
+ ERR_PRINTF2(_L("Need %S in INI file"), &KLengthKey());
+ SetBlockResult(EFail);
+ }
+ }
+
+TInt CTraceCoreDataWrapper::LoadLdd(const TDesC& aLddName, TBool aSingleUse)
+ {
+ TInt err = User::LoadLogicalDevice(aLddName);
+ if (err == KErrNone)
+ {
+ INFO_PRINTF2(_L("LDD %S successfully loaded with no error"), &aLddName);
+ }
+ else if (err == KErrAlreadyExists && !aSingleUse)
+ {
+ INFO_PRINTF2(_L("LDD %S was already loaded"), &aLddName);
+ }
+ else
+ {
+ ERR_PRINTF3(_L("LoadLogicalDevice(%S) error %d"), &aLddName, err);
+ SetError(err);
+ }
+ return err;
+ }
+
+TBool CTraceCoreDataWrapper::LoadLdd(const TDesC& aLddName, const TTEFSectionName& aSection)
+ {
+ TBool singleUse = EFalse;
+ GetBoolFromConfig(aSection, KSingleUseKey(), singleUse);
+
+ TBool isLoadedAlready = EFalse;
+ TInt err = LoadLdd(aLddName, singleUse);
+ if (!singleUse)
+ {
+ isLoadedAlready = (err == KErrAlreadyExists);
+ }
+
+ return isLoadedAlready;
+ }
+
+TInt CTraceCoreDataWrapper::FreeLdd(const TDesC& aLddName)
+ {
+ TInt err = User::FreeLogicalDevice(aLddName);
+ if (err == KErrNone)
+ {
+ INFO_PRINTF2(_L("LDD %S successfully freed with no error"), &aLddName);
+ }
+ else
+ {
+ ERR_PRINTF3(_L("FreeLogicalDevice(%S) error %d"), &aLddName, err);
+ //Won't set error from this until
+ //issue with always returning KErrInUse
+ //User::FreeLogicalDevice() is resolved
+ //SetError(err);
+ }
+ return err;
+ }
+
+template <class T>
+TInt CTraceCoreDataWrapper::OpenLdd(const TDesC& aLddName, T& aLdd)
+ {
+ TInt err = aLdd.Open();
+ if (err != KErrNone)
+ {
+ ERR_PRINTF3(_L("%S Open() error %d"), &aLddName, err);
+ SetError(err);
+ }
+ else
+ {
+ INFO_PRINTF2(_L("%S successfully set up"), &aLddName);
+ }
+ return err;
+ }
+
+template <class T>
+TBool CTraceCoreDataWrapper::OpenLdd(const TDesC& aLddName, T& aLdd, const TTEFSectionName& aSection)
+ {
+ TBool openLdd = ETrue;
+ GetBoolFromConfig(aSection, KOpenLddKey(), openLdd);
+
+ if (openLdd)
+ {
+ OpenLdd(aLddName, aLdd);
+ }
+
+ return openLdd;
+ }
+
+void CTraceCoreDataWrapper::DoCmdSetUpTcLdd(const TTEFSectionName& aSection)
+ {
+ iTcLddLoadedAtStart = LoadLdd(KTcLdd(), aSection);
+
+ OpenLdd(KTcLdd(), iTcLdd, aSection);
+ }
+
+void CTraceCoreDataWrapper::DoCmdCleanUpTcLdd(const TTEFSectionName& aSection)
+ {
+ TBool closeLdd = ETrue;
+ GetBoolFromConfig(aSection, KCloseLddKey(), closeLdd);
+
+ if (closeLdd)
+ {
+ iTcLdd.Close();
+ }
+
+ if (!iTcLddLoadedAtStart)
+ {
+ FreeLdd(KTcLdd());
+ }
+ }
+
+void CTraceCoreDataWrapper::DoCmdSetUpTcOstLdd(const TTEFSectionName& aSection)
+ {
+ iTcOstLddLoadedAtStart = LoadLdd(KTraceCoreOstLdd(), aSection);
+
+ if (OpenLdd(KTraceCoreOstLdd(), iTraceCoreOstLdd, aSection))
+ {
+ //Switch to OstMemoryWriter
+ TUint32 writer(1);
+ iTraceCoreOstLdd.ChangeWriter(writer);
+
+ TUint32 handle;
+ TInt err = iTraceCoreOstLdd.GetChunkHandle(handle);
+ if (err != KErrNone)
+ {
+ ERR_PRINTF2(_L("GetChunkHandle() error %d"), err);
+ SetError(err);
+ }
+
+ TInt bufferSize = KDefaultBufferSize;
+ GetIntFromConfig(aSection, KBufferSizeKey(), bufferSize);
+ INFO_PRINTF2(_L("Calling SetBufferSize(%d)"), bufferSize);
+ err = iTraceCoreOstLdd.SetBufferSize((TUint32&) bufferSize);
+ if (err != KErrNone)
+ {
+ ERR_PRINTF2(_L("SetBufferSize() error %d"), err);
+ SetError(err);
+ }
+ }
+ }
+
+void CTraceCoreDataWrapper::DoCmdCleanUpTcOstLdd(const TTEFSectionName& aSection)
+ {
+ TBool closeLdd = ETrue;
+ GetBoolFromConfig(aSection, KCloseLddKey(), closeLdd);
+
+ if (closeLdd)
+ {
+ iTraceBuffer.Close();
+ //Switch back to XtiWriter
+ TUint32 writer(0);
+ iTraceCoreOstLdd.ChangeWriter(writer);
+ iTraceCoreOstLdd.Close();
+ }
+
+ if (!iTcOstLddLoadedAtStart)
+ {
+ FreeLdd(KTraceCoreOstLdd());
+ }
+ }
+
+void CTraceCoreDataWrapper::DoCmdSetUpTraceOnActivation(const TTEFSectionName& aSection)
+ {
+ iTraceOnActivationLoadedAtStart = LoadLdd(KTraceOnActivationLdd(), aSection);
+
+ OpenLdd(KTraceOnActivationLdd(), iTraceOnActivationLdd, aSection);
+ }
+
+void CTraceCoreDataWrapper::DoCmdCleanUpTraceOnActivation(const TTEFSectionName& aSection)
+ {
+ TBool closeLdd = ETrue;
+ GetBoolFromConfig(aSection, KCloseLddKey(), closeLdd);
+
+ if (closeLdd)
+ {
+ iTraceOnActivationLdd.Close();
+ }
+
+ if (!iTraceOnActivationLoadedAtStart)
+ {
+ FreeLdd(KTraceOnActivationLdd());
+ }
+ }
+
+void CTraceCoreDataWrapper::DoCmdActivateDeactivateTrace(const TTEFSectionName& aSection)
+ {
+ TInt groupId;
+ TInt componentId;
+ TBool activate;
+ // Get all required parameters from INI file
+ if ( GetIntFromConfig(aSection, KGroupIdKey(), groupId) &&
+ GetHexFromConfig(aSection, KComponentIdKey(), componentId) &&
+ GetBoolFromConfig(aSection, KActivateKey(), activate) )
+ {
+ RTcDriverParameters tcDriverParameters;
+ tcDriverParameters.iGroupId = groupId;
+ tcDriverParameters.iComponentId = componentId;
+ tcDriverParameters.iActivation = EFalse;
+ TInt err = KErrNone;
+ if (activate)
+ {
+ INFO_PRINTF3(_L("Calling ActivateTrace(%d,0x%x)"), groupId, componentId);
+ err = iTcLdd.ActivateTrace(tcDriverParameters);
+ if (err != KErrNone)
+ {
+ ERR_PRINTF4(_L("ActivateTrace(%d,0x%x) error %d"), groupId, componentId, err);
+ SetError(err);
+ }
+ }
+ else
+ {
+ INFO_PRINTF3(_L("Calling DeactivateTrace(%d,0x%x)"), groupId, componentId);
+ err = iTcLdd.DeactivateTrace(tcDriverParameters);
+ if (err != KErrNone)
+ {
+ ERR_PRINTF4(_L("DeactivateTrace(%d,0x%x) error %d"), groupId, componentId, err);
+ SetError(err);
+ }
+ }
+ }
+ else
+ {
+ ERR_PRINTF4(_L("Need %S, %S and %S in INI file"), &KGroupIdKey(), &KComponentIdKey(), &KActivateKey());
+ SetBlockResult(EFail);
+ }
+ }
+
+void CTraceCoreDataWrapper::DoCmdReadTracesFromBuffer()
+ {
+ iTraceBuffer.Close();
+ TInt bufferSize = iTraceCoreOstLdd.GetBufferSize();
+
+ TInt err = iTraceBuffer.ReAlloc(bufferSize);
+ if (err != KErrNone)
+ {
+ ERR_PRINTF3(_L("ReAlloc(%d) error %d"), bufferSize, err);
+ SetError(err);
+ }
+
+ INFO_PRINTF2(_L("Calling ReadNTraces() with buffer size %d"), bufferSize);
+ err = iTraceCoreOstLdd.ReadNTraces(iTraceBuffer);
+ if (err != KErrNone)
+ {
+ ERR_PRINTF2(_L("ReadNTraces() error %d"), err);
+ SetError(err);
+ }
+ else
+ {
+ INFO_PRINTF2(_L("%d bytes of trace data read"), iTraceBuffer.Size());
+ // Print the trace data to the log, if there's not too much of it
+ if (iTraceBuffer.Size() <= KDefaultBufferSize && iTraceBuffer.Size() > 0)
+ {
+ TBuf<KDefaultBufferSize> tempBuffer;
+ tempBuffer.Copy(iTraceBuffer);
+ INFO_PRINTF2(_L("Trace data:\r\n%S"), &tempBuffer);
+ }
+ }
+
+ err = iTraceCoreOstLdd.ClearBuffer();
+ if (err != KErrNone)
+ {
+ ERR_PRINTF2(_L("ClearBuffer() error %d"), err);
+ SetError(err);
+ }
+ }