// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the License "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:
// A helper test driver for testing Kernel Performance Logger implementation.
//
//
/**
@file
*/
#include "d_perflogger_ldd.h"
#include <kernperflogger.h>
_LIT(KDFCThreadName,"D_PL_DFC_THREAD");
const TInt KDFCThreadPriority=27;
//-----------------------------------------------------------------------------------
DKPLoggerTestHelperLDD* DKPLoggerTestHelperLDD::pSelf = NULL; //-- static pointer to the single instance of the logical channel class
//-----------------------------------------------------------------------------------
DLogTicker::DLogTicker() : iTimer(LogTimerCallback,this) //-- initialize log events generator
{
iLogDFC = NULL;
iRequest = NULL;
iUserThreadContext = NULL;
}
DLogTicker::~DLogTicker()
{
Cancel(); //-- cancel user request, DFC, timers etc.
Kern::DestroyClientRequest(iRequest);
delete iLogDFC;
}
//-----------------------------------------------------------------------------------
/**
Construct ticker object. Creates appropriate TDfc object for dealing with IDFC or DFC
@param apUserThreadContext pointer to the user thread context where the request will be completed in
@param apDfcQ pointer to the DFC queue this object will be using.
@param aLogContext specfies the context (ISR, DFC or IDFC) the logging will be made from. Can be NKern::EIDFC, NKern::EThread, NKern::EInterrupt
*/
void DLogTicker::Construct(DThread* aUserThreadContext, TDfcQue* aDfcQ, NKern::TContext aLogContext)
{
__NK_ASSERT_DEBUG(aUserThreadContext && aDfcQ);
iLogContext = aLogContext;
if(aLogContext == NKern::EIDFC)
{//-- we will deal with IDFC, create appropriate DFC object
iLogDFC = new TDfc(LogDFC, this);
}
else
{
if(aLogContext == NKern::EThread || aLogContext == NKern::EInterrupt)
{//-- we will deal with DFC or ISR
iLogDFC = new TDfc(LogDFC, this, aDfcQ, 0);
}
else
{//-- wrong value
__PRINT("#KPLogTest:DLogTicker::Construct() wrong context request !");
__NK_ASSERT_DEBUG(0);
}
}
__NK_ASSERT_ALWAYS(iLogDFC);
TInt r = Kern::CreateClientRequest(iRequest);
__NK_ASSERT_ALWAYS(r == KErrNone);
iUserThreadContext = aUserThreadContext; //-- store user thread context co complete requests correctly
// iLogDFC->SetDfcQ(aDfcQ); //-- attach to the given DFC queue. !!!!DON'T DO THIS FOR IDFC!!!!!
}
//-----------------------------------------------------------------------------------
/**
Start the state machine by scheduling a DFC (or IDFC)
@param apLogControl log parameters structure
@param apRqStat pointer to the user request staus object that will be completed when all loggings done.
*/
void DLogTicker::Start(const TTestLogCtrl* aLogControl, TRequestStatus* aRqStat)
{
__NK_ASSERT_DEBUG(aLogControl && aRqStat && iLogDFC);
kumemget32(&iLogControl, aLogControl, sizeof(TTestLogCtrl)); //-- copy control structure from the user side
__NK_ASSERT_DEBUG(iLogControl.iLogsNum>=0);
__PRINT1("#KPLogTest:DLogTicker::Start() for %d loggings",iLogControl.iLogsNum);
if (iRequest->SetStatus(aRqStat) != KErrNone)
{//-- current request is pending, panic client thread
__PRINT("#KPLogTest:DLogTicker::Start() request is already pending !");
Kern::PanicCurrentThread(KPLoggerHelperTestDrv, EReqAlreadyPending);
}
if(iLogContext == NKern::EIDFC)
{//-- DLogTicker::LogDFC() will be called as IDFC
NKern::Lock();
iLogDFC->Add(); //-- start
NKern::Unlock();
}
else
{//-- DLogTicker::LogDFC() will be called as DFC
iLogDFC->Enque(); //-- start
}
}
//-----------------------------------------------------------------------------------
/**
Complete the user request when all logging done.
This can be called from 2 concurrent places - DFC & NTimer callback, either of them can complete the request
@param aCompletionCode request completion code
*/
void DLogTicker::CompleteRequest(TInt aCompletionCode/*=KErrNone*/)
{
Kern::QueueRequestComplete(iUserThreadContext, iRequest, aCompletionCode);
}
//-----------------------------------------------------------------------------------
/**
Cancel everything
*/
void DLogTicker::Cancel(void)
{
CompleteRequest(KErrCancel); //-- cancel user request
iLogControl.iLogsNum = 0; // Prevent DFC from restarting the timer
iTimer.Cancel(); //-- cancel Timer
iLogDFC->Cancel(); //-- cancel DFC
}
//-----------------------------------------------------------------------------------
/**
Ticker timer callback. Can be called in ISR or DFC context.
If called in ISR context, makes logging, and schedules a DFC to complete the request if needed.
If called in DFC context, makes logging for DFC (not for IDFC) mode and completes the request if needed.
@param apSelf pointer to the DLogTicker object
*/
void DLogTicker::LogTimerCallback(TAny* aSelf)
{
DLogTicker *pSelf = (DLogTicker*)aSelf;
__NK_ASSERT_DEBUG(pSelf);
TTestLogCtrl& logClontrol = pSelf->iLogControl;
__NK_ASSERT_DEBUG(logClontrol.iLogsNum >=0);
TInt context = NKern::CurrentContext();
if(context == NKern::EInterrupt)
{//-- This callback is from ISR
//-- make logging from ISR context, category field is ignored, it will be FastTrace::EKernPerfLog
PERF_LOG(logClontrol.iSubCategory, logClontrol.iUserData, logClontrol.iUserData2);
//-- kick DFC, it will probaly complete the request.
pSelf->iLogDFC->Add();
}
else
{//-- this is a DFC callback, but the DFC object could also have been ceated as IDFC
//-- complete user request here if necessarily.
if(pSelf->iLogDFC->IsIDFC())
{//-- the logging will be made in IDFC function.
if(pSelf->iLogControl.iLogsNum == 0)
{//-- all done, complete the request here, because we can't do in in IDFC
pSelf->CompleteRequest();
}
else
{//-- this callback came from IDFC object, kick IDFC in a special way.
NKern::Lock();
pSelf->iLogDFC->Add();
NKern::Unlock();
}
}
else
{//-- this callback came from IDFC object, make logging from DFC context
//-- category field is ignored, it will be FastTrace::EKernPerfLog
PERF_LOG(logClontrol.iSubCategory, logClontrol.iUserData, logClontrol.iUserData2);
pSelf->iLogDFC->Enque(); //-- kick DFC
}
}
}
//-----------------------------------------------------------------------------------
/**
Ticker DFC or IDFC function. Kicks the timer;
If is called as IDFC, makes logging in this context and schedules a timer callback in DFC context to complete the request.
If is called as DFC, schedules timer callback in DFC or ISR context.
@param apSelf pointer to the DLogTicker object
*/
void DLogTicker::LogDFC(TAny* aSelf)
{
DLogTicker *pSelf = (DLogTicker*)aSelf;
__NK_ASSERT_DEBUG(pSelf);
TInt context = NKern::CurrentContext();
(void)context; //-- avoid warning in release mode
if(pSelf->iLogControl.iLogsNum <= 0)
{//-- complete user request, all done. The request can also be completed in LogTimerCallback()
//-- in case if this is a IDFC and callback is a DFC
pSelf->CompleteRequest();
}
else
{
TTestLogCtrl& logClontrol = pSelf->iLogControl;
logClontrol.iLogsNum--; //-- decrease remaining number of loggings
if(pSelf->iLogDFC->IsIDFC())
{//-- we are in IDFC context, make logging from here, timer callback won't be IDFC
__NK_ASSERT_DEBUG(context == NKern::EIDFC);
//-- category field is ignored, it will be FastTrace::EKernPerfLog
PERF_LOG(logClontrol.iSubCategory, logClontrol.iUserData, logClontrol.iUserData2);
//-- kick the timer to have a callback in a specified time in DFC context
//-- timer's DFC will complete the request if necessarily.
pSelf->iTimer.OneShot(logClontrol.iLogPeriodTick, ETrue);
}
else
{//-- we are in DFC context, kick the timer to have a callback in a specified time in ISR or DFC context
pSelf->iTimer.OneShot(logClontrol.iLogPeriodTick, !(pSelf->iLogContext == NKern::EInterrupt));
}
}
}
//-----------------------------------------------------------------------------------
//###################################################################################
//# DKPLoggerTestHelperLDD class implementation
//###################################################################################
DKPLoggerTestHelperLDD::DKPLoggerTestHelperLDD()
{
//-- store the pointer to the current thread for request completion from ISR->DFC
iClientThread = &Kern::CurrentThread();
__NK_ASSERT_DEBUG(iClientThread);
//-- Open client's user thread, incrementing ref. counter
TInt nRes = iClientThread->Open();
__NK_ASSERT_DEBUG(nRes == KErrNone);
(void)nRes;//-- avoid warning in release mode
//-- initialize DFC machinery
//iDfcQ = Kern::DfcQue0(); //-- attach to the low priority DFC queue
if (!iDfcQ)
{
TInt r = Kern::DynamicDfcQCreate(iDfcQ, KDFCThreadPriority, KDFCThreadName);
if (r!= KErrNone)
{
return;
}
#ifdef CPU_AFFINITY_ANY
NKern::ThreadSetCpuAffinity((NThread*)(iDfcQ->iThread), KCpuAffinityAny);
#endif
}
iIsrLogTicker.Construct (iClientThread, iDfcQ, NKern::EInterrupt);//-- construct ISR log ticker
iDfcLogTicker.Construct (iClientThread, iDfcQ, NKern::EThread); //-- construct DFC log ticker
iIDfcLogTicker.Construct(iClientThread, iDfcQ, NKern::EIDFC); //-- construct IDFC log ticker
}
//-----------------------------------------------------------------------------------
DKPLoggerTestHelperLDD::~DKPLoggerTestHelperLDD()
{
__PRINT("#KPLogTest:~DKPLoggerTestHelperLDD()");
iClientThread->Close(NULL);
if (iDfcQ)
iDfcQ->Destroy();
pSelf = NULL; //-- clear the pointer to this class instance
}
//-----------------------------------------------------------------------------------
/**
static factory function for the LDD.
@return pointer to the created (or existing) instance of the class
*/
DKPLoggerTestHelperLDD* DKPLoggerTestHelperLDD::CreateInstance()
{
__PRINT("#KPLogTest:DKPLoggerTestHelperLDD::CreateInstance()");
//-- create LDD channel instance
if(pSelf)
{//-- this is a singleton, can't have more than one instance
__PRINT("#DKPLoggerTestHelperLDD::CreateInstance(): Attempt to create a second instance of a singleton!");
return pSelf;
}
pSelf = new DKPLoggerTestHelperLDD;
if(!pSelf)
{//-- OOM
__PRINT("#KPLogTest:DKPLoggerTestHelperLDD::CreateInstance(): Unable to create class instance !");
}
return pSelf;
}
//-----------------------------------------------------------------------------------
/**
LDD second stage constructor
*/
TInt DKPLoggerTestHelperLDD::DoCreate(TInt /*aUnit*/, const TDesC8* /*anInfo*/, const TVersion& aVer)
{
//-- check if the version aVer is supported
if (!Kern::QueryVersionSupported(TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber),aVer))
return KErrNotSupported;
return KErrNone;
}
//-----------------------------------------------------------------------------------
/**
Requests processing function.
@return request processing error code.
*/
TInt DKPLoggerTestHelperLDD::Request(TInt aFunction, TAny* a1, TAny* a2)
{
TInt nRes = KErrNone;
if (aFunction == KMaxTInt)
{//-- this is DoCancel()
TUint reqMask = (TUint)a1;
DoCancel(reqMask);
return KErrNone;
}
if(aFunction < 0)
{//-- This is DoRequest()
//-- extract request parameters
TRequestStatus* pRqStat=(TRequestStatus*)a1;
TAny* params[2];
kumemget32(params, a2, sizeof(params));
nRes = DoRequest(~aFunction, pRqStat, params[0], params[1]);
}
else
{//-- This is DoControl()
nRes = DoControl(aFunction, a1, a2);
}
return nRes;
}
//-----------------------------------------------------------------------------------
/**
Cancel outstanding request(s)
@param aReqNumber request number to cancel
*/
void DKPLoggerTestHelperLDD::DoCancel(TUint aReqNumber)
{
switch (aReqNumber)
{
//-- cancel logging from ISR.
case RKPLoggerTestHelper::EDoLogFromISR:
iIsrLogTicker.Cancel();
break;
//-- cancel logging from IDFC.
case RKPLoggerTestHelper::EDoLogFromIDFC:
iIDfcLogTicker.Cancel();
break;
//-- cancel logging from DFC.
case RKPLoggerTestHelper::EDoLogFromDFC:
iDfcLogTicker.Cancel();
break;
default:
__PRINT1("#KPLogTest:DKPLoggerTestHelperLDD::DoCancel Cancelling a wrong request number:%d!", aReqMask);
Kern::PanicCurrentThread(KPLoggerHelperTestDrv, EWrongRequest);
break;
}
}
//-----------------------------------------------------------------------------------
/**
Asynchronous request processing.
@param aFunction request function number, see RKPLoggerTestHelper::TControl
@param apRqStat pointer to the user's request status object.
@param apArg1 pointer to the 1st parameter in RKPLoggerTestHelper::DoRequest
@param apArg2 pointer to the 2nd parameter in RKPLoggerTestHelper::DoRequest
@return request scheduling result, system-wide error code.
*/
TInt DKPLoggerTestHelperLDD::DoRequest(TInt aReqNumber, TRequestStatus* aRqStat, TAny* aArg1, TAny* /*apArg2*/)
{
switch (aReqNumber)
{
//-- make logging from ISR.
case RKPLoggerTestHelper::EDoLogFromISR:
{
__PRINT("#KPLogTest: making loggings from ISR context");
iIsrLogTicker.Start((const TTestLogCtrl*)aArg1, aRqStat);
}
break;
//-- make logging from IDFC.
case RKPLoggerTestHelper::EDoLogFromIDFC:
{
__PRINT("#KPLogTest: making loggings from IDFC context");
iIDfcLogTicker.Start((const TTestLogCtrl*)aArg1, aRqStat);
}
break;
//-- make logging from DFC.
case RKPLoggerTestHelper::EDoLogFromDFC:
{
__PRINT("#KPLogTest: making loggings from DFC context");
iDfcLogTicker.Start((const TTestLogCtrl*)aArg1, aRqStat);
}
break;
default:
__PRINT1("#KPLogTest:DKPLoggerTestHelperLDD::DoRequest() Wrong request number:%d!", aReqNumber);
Kern::PanicCurrentThread(KPLoggerHelperTestDrv, EWrongRequest);
break;
}
return KErrNone;
}
//-----------------------------------------------------------------------------------
/**
Synchronous requests processing.
@param aFunction request function number, see RKernPerfLogger::TControl
@param apArg1 pointer to the 1st parameter in RKernPerfLogger::DoControl
@param apArg2 pointer to the 2n parameter in RKernPerfLogger::DoControl
@return request processing result
*/
TInt DKPLoggerTestHelperLDD::DoControl(TInt aFunction, TAny* aArg1, TAny* /*apArg2*/)
{
switch (aFunction)
{
//-- make test logging from the user thread
case RKPLoggerTestHelper::EDoLogFromUserThread:
{
kumemget32(&iLogControlUserThread, aArg1, sizeof(iLogControlUserThread)); //-- copy control structure from the user side
__PRINT1("#KPLogTest: making %d loggings from a user-thread context", iLogControlUserThread.iLogsNum);
__NK_ASSERT_DEBUG(iLogControlUserThread.iLogsNum >=0 );
//-- This context is actually, a user thread. Make logging from here
for(TInt i=0; i<iLogControlUserThread.iLogsNum; ++i)
{
//-- category field is ignored, it will be FastTrace::EKernPerfLog
PERF_LOG(iLogControlUserThread.iSubCategory, iLogControlUserThread.iUserData, iLogControlUserThread.iUserData2);
NKern::Sleep(iLogControlUserThread.iLogPeriodTick);
}
}
break;
//-- unit test for different PERF_LOG macros
case RKPLoggerTestHelper::EDoTestMacros:
{
kumemget32(&iLogControlUserThread, aArg1, sizeof(iLogControlUserThread)); //-- copy control structure from the user side
__PRINT1("#KPLogTest: making %d loggings from a user-thread context, testing different macros", iLogControlUserThread.iLogsNum);
__NK_ASSERT_DEBUG(iLogControlUserThread.iLogsNum >=0 );
for(TInt i=0; i<iLogControlUserThread.iLogsNum; ++i)
{
PERF_LOG0(iLogControlUserThread.iSubCategory);
PERF_LOG1(iLogControlUserThread.iSubCategory, iLogControlUserThread.iUserData);
PERF_LOG (iLogControlUserThread.iSubCategory, iLogControlUserThread.iUserData, iLogControlUserThread.iUserData2);
NKern::Sleep(iLogControlUserThread.iLogPeriodTick);
}
}
break;
default:
__PRINT1("#KPLogTest:DKPLoggerTestHelperLDD::DoControl() Wrong function number:%d!", aFunction);
Kern::PanicCurrentThread(KPLoggerHelperTestDrv, EWrongRequest);
break;
};
return KErrNone;
}
//###################################################################################
//# LDD factory, DKPLoggerTestHelperLDDFactory class implementation
//###################################################################################
DKPLoggerTestHelperLDDFactory::DKPLoggerTestHelperLDDFactory()
{
iUnitsMask = 0x00; //-- don't support units
iVersion=TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);
}
DKPLoggerTestHelperLDDFactory::~DKPLoggerTestHelperLDDFactory()
{
__PRINT("#KPLogTest:~DKPLoggerTestHelperLDDFactory()");
}
//-----------------------------------------------------------------------------------
/**
static factory function for the LDD factory.
@return pointer to the created instance of the class
*/
DKPLoggerTestHelperLDDFactory* DKPLoggerTestHelperLDDFactory::CreateInstance()
{
__PRINT("#KPLogTest:DKPLoggerTestHelperLDDFactory::CreateInstance()");
//-- create LDD factory
DKPLoggerTestHelperLDDFactory* pSelf = new DKPLoggerTestHelperLDDFactory;
if(!pSelf)
{//-- OOM
__PRINT("#KPLogTest:DKPLoggerTestHelperLDDFactory::CreateInstance(): Unable to create class instance !");
}
return pSelf;
}
//-----------------------------------------------------------------------------------
/**
*/
TInt DKPLoggerTestHelperLDDFactory::Install()
{
return SetName(&KPLoggerHelperTestDrv); // Set our name and return error code
}
//-----------------------------------------------------------------------------------
/**
*/
void DKPLoggerTestHelperLDDFactory::GetCaps(TDes8& /*aDes*/) const
{//-- not supported
}
//-----------------------------------------------------------------------------------
/**
LDD factory function. Creates LDD object.
@param aChannel A pointer to an LDD channel object which will be initialised on return.
@return KErrNone if object successfully allocated, KErrNoMemory if not.
@return KErrAlreadyExists if the client tries to creae more than 1 instance of the channel
*/
TInt DKPLoggerTestHelperLDDFactory::Create(DLogicalChannelBase*& aChannel)
{
if(DKPLoggerTestHelperLDD::pSelf)
{//-- channel is a singleton, can't have more than one instance
__PRINT("#DKPLoggerTestHelperLDDFactory::Create: Attmpt to create another instance of the LDD!");
return KErrAlreadyExists;
}
aChannel = DKPLoggerTestHelperLDD::CreateInstance();
if(!aChannel)
return KErrNoMemory;
return KErrNone;
}
//-----------------------------------------------------------------------------------
/**
"Standard LDD" entrypoint.
Is called on CreateLogicalDevice() if the user calls LoadLogicalDevice(). Creates LDD factory.
@return pointer to the LDD factory object.
*/
DECLARE_STANDARD_LDD()
{
DKPLoggerTestHelperLDDFactory* pLDDFactory = DKPLoggerTestHelperLDDFactory::CreateInstance();
return pLDDFactory;
}