diff -r a151135b0cf9 -r aa2539c91954 tracesrv/tracecore/btrace_handler/test/TEF/te_tracecore/src/te_tracecore_datawrapper.cpp --- /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 +#include + +#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 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 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; iAttribs(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 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 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 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 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 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 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 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 givenString; + givenString.Copy(aString); + for (TInt i=1; i<=aSequenceLength; i++) + { + TBuf8 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 +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 +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 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); + } + }