// 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:
// e32test\debug\d_tracecore.cpp
// 
//

#include <kernel/kern_priv.h>
#include <kernel/kernel.h>

#include <e32btrace.h>
#include <opensystemtrace_types.h>

#ifndef __SMP__
#include <nkern/nkern.h>
#else
#include <nkernsmp/nkern.h>
#endif //__SMP__
#include <TraceCoreTraceActivationIf.h>
#include <TraceCoreNotificationReceiver.h>
#include "TraceCore.h"
#include "d_tracecore.h"


#include "TraceCoreTestWriter.h"
#include "TestDataWriterNotifier.h"

const TInt KFrameBufferLength = 4096;

class DTraceCoreTestFactory : public DLogicalDevice 
	{
public:
	virtual TInt Install();
	virtual void GetCaps(TDes8& aDes) const;
	virtual TInt Create(DLogicalChannelBase*& aChannel);
	};

class DTraceCoreTestChannel : public DLogicalChannel, MTestWriterNotifier, MTraceCoreNotificationReceiver
	{
public:
	DTraceCoreTestChannel();
	virtual ~DTraceCoreTestChannel();
	//	Inherited from DObject
	virtual TInt RequestUserHandle(DThread* aThread, TOwnerType aType);
	// Inherited from DLogicalChannelBase
	virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);
	virtual void HandleMsg(TMessageBase* aMsg);
	TInt DoControl(TInt aFunction, TAny* a1, TAny* a2);
	TInt DoRequest(TInt aId, TRequestStatus* aStatus, TAny* a1, TAny* a2);
	
    // Virtual from MTraceCoreNotificationReceiver. Called from TraceCore.
    void TraceActivated( TUint32 aComponentId, TUint16 aGroupId  );
    void TraceDeactivated( TUint32 aComponentId, TUint16 aGroupId  );
	

private:
	DThread* iClient;
	
private:
	void ActivateTrace(TcDriverParameters& aDriverParameters, TInt aNumTraces);
	void DeactivateTrace(TcDriverParameters& aDriverParameters, TInt aNumTraces);
    TInt RefreshActivations();
    TInt ValidateFilterSync(TcDriverParameters& aDriverParams);
    void DropNextTrace(TBool aDrop);
    void RegisterActivationNotification(TcDriverParameters& aDriverParameters, TBool aRegister);
    TInt CheckActivationNotificationOk(TBool aShouldBeNotified);
	
	TInt CreateWriter();
	// from MTestWriterNotifier
    virtual void WriteComplete(TNotifyData aData);
    virtual void WriteStart();
private:
  
    TRequestStatus* iTraceDataRequestStatus;      // request status for asynct trace requests
    TDes8*          iTraceDataDestination;        // pointer to write trace data to
    TDynamicDfcQue* iOstTestDriverDfcQ;           // Dedicated non-realtime DfcQ
    TBool           iDropTrace;                   // if test doesn't want trace to actually be sent
    TInt                            iFrameCount;  // Number of frames to capture before notify is issued 
    TBuf8<KFrameBufferLength>       iFrameBuffer; // the frame buffer
    TBool           iFilterInSyncWhenNotified;    // If true, filter in TraceCore was in sync with the notification
    TBool           iNotificationReceived;        // If true, trace activation notification was received
	};

const TInt KTestOstDriverThreadPriority = 24;
_LIT(KTestOstDriverThread,"d_tracecore_dfcq");


//
// DTraceCoreTestFactory
//

TInt DTraceCoreTestFactory::Install()
	{
	return SetName(&RTraceCoreTest::Name());
	}

void DTraceCoreTestFactory::GetCaps(TDes8& aDes) const
	{
	Kern::InfoCopy(aDes,0,0);
	}

TInt DTraceCoreTestFactory::Create(DLogicalChannelBase*& aChannel)
	{
	aChannel=new DTraceCoreTestChannel();
	if(!aChannel)
		return KErrNoMemory;
	return KErrNone;
	}


//
// DTraceCoreTestChannel
//

DTraceCoreTestChannel::DTraceCoreTestChannel()
: iTraceDataRequestStatus(NULL)
, iTraceDataDestination(NULL)
, iDropTrace(EFalse)
, iFilterInSyncWhenNotified(EFalse)
    {
	}

DTraceCoreTestChannel::~DTraceCoreTestChannel()
	{	
	// Detatch (stop notifications) from writer	     
    DTraceCoreTestWriter* testWriter = DTraceCoreTestWriter::GetInstance();
    if(testWriter)
        {
        testWriter->SetNotifier(NULL);        
        }           
    delete testWriter;
    
    //destroy dfcq
    if (iOstTestDriverDfcQ)
        {
        iOstTestDriverDfcQ->Destroy();
        }
	}

TInt DTraceCoreTestChannel::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& /*aVer*/)
	{
    TDynamicDfcQue* q;
    TInt ret = Kern::DynamicDfcQCreate(q, KTestOstDriverThreadPriority , KTestOstDriverThread);
    if (ret==KErrNone)
        {
        //disable real-time state of the dfcq
        q->SetRealtimeState(ERealtimeStateOff);
        iOstTestDriverDfcQ=q;
        SetDfcQ(iOstTestDriverDfcQ);
        iMsgQ.Receive();
        }
    else
        {
        Kern::Printf("Kern::DynamicDfcQCreate returned with error: %d",ret);
        return ret;
        }
	iClient = &Kern::CurrentThread();			
	return CreateWriter();
	}

void DTraceCoreTestChannel::WriteStart()
    {
    }

void DTraceCoreTestChannel::WriteComplete(TNotifyData aNotifyData) 
    {

    if(iTraceDataRequestStatus && iFrameCount > 0 )
        {    

        // append the data into the frame buffer if it fits
        if( iFrameBuffer.Length() + aNotifyData.iLen < KFrameBufferLength)
            {        
            iFrameBuffer.Append(TPtrC8((TUint8*)aNotifyData.iAddr, aNotifyData.iLen ));
            }
        else
            {
            // force a send of what we have
            iFrameCount = 1;
            }
                       
        if( --iFrameCount == 0)
            {    
            if (iDropTrace)
                {
                // test client is requesting we force tracecore to drop the next trace
                // so we call the same function that a writer would call ( SetPreviousTraceDropped )
                // in order to notify tracecore that a trace has been dropped            
                DTraceCore* tracecore = DTraceCore::GetInstance();
                tracecore->SetPreviousTraceDropped(ETrue);
                }
            else//send the trace
                {
                Kern::KUDesPut(*iTraceDataDestination,iFrameBuffer);
                }
            
            // complete the clients request
            Kern::RequestComplete(iTraceDataRequestStatus, 0);
            iTraceDataRequestStatus = NULL;
            iFrameBuffer.Zero();            
            }
        }    
    }

TInt DTraceCoreTestChannel::CreateWriter()
    {
    TInt r = KErrNoMemory;
    DTraceCoreTestWriter* testWriter = DTraceCoreTestWriter::GetInstance(); 
    if(testWriter)
        {
        r = KErrNone;
        testWriter->SetNotifier(this);
        }       
    return r;
    }

TInt DTraceCoreTestChannel::RequestUserHandle(DThread* aThread, TOwnerType aType)
	{
	if (aType!=EOwnerThread || aThread!=iClient)
		return KErrAccessDenied;
	return KErrNone;
	}

void DTraceCoreTestChannel::HandleMsg(TMessageBase* aMsg)
	{    
    TThreadMessage& msg = *(static_cast<TThreadMessage*>(aMsg));    
    TInt id = msg.iValue;
    
    if ( id == static_cast<TInt>( ECloseMsg ) )
        {

        // Don't receive any more messages
        msg.Complete( KErrNone, EFalse );

        // Complete all outstanding messages on this queue
        iMsgQ.CompleteAll( KErrServerTerminated );
        }
    else if ( id == KMaxTInt )
        {
        // 'DoCancel' message
        TRequestStatus* pS = reinterpret_cast<TRequestStatus*>( msg.Ptr0() );
        Kern::RequestComplete(iClient,pS,KErrCancel);
        msg.Complete( KErrNone, ETrue );
        }
    else if ( id < 0 )
        {
        // DoRequest
        TRequestStatus* pS = reinterpret_cast<TRequestStatus*>( msg.Ptr0() );
        
        TInt ret = DoRequest( ~id, pS, msg.Ptr1(), msg.Ptr2());
        if ( ret != KErrNone )
            {
            Kern::RequestComplete( iClient, pS, ret );
            }//noelse
        
        msg.Complete( KErrNone, ETrue );
        }
    else
        {
        // DoControl
        TInt ret = DoControl( id, msg.Ptr0(), msg.Ptr1() );
        msg.Complete( ret, ETrue );
        }

	}

TInt DTraceCoreTestChannel::DoControl(TInt aFunction, TAny* a1, TAny* a2)
    {
    switch(aFunction)
          {
    // test functions
          case RTraceCoreTest::EActivateTrace:
              {
//            Kern::Printf("DTraceCoreTestChannel::DoControl() RTraceCoreTest::EActivateTrace");
              TcDriverParameters* tcDriverParameters = static_cast<TcDriverParameters*>(a1); 
              __ASSERT_ALWAYS(tcDriverParameters!=NULL, Kern::Fault("DTraceCoreTestChannel::DoControl: NULL parameter!", __LINE__) );
              ActivateTrace(*tcDriverParameters, (TInt)(a2));
              return KErrNone;
              }
         case RTraceCoreTest::EDeactivateTrace:
              {
//            Kern::Printf("DTraceCoreTestChannel::DoControl()  RTraceCoreTest::EDeactivateTrace");
              TcDriverParameters* tcDriverParameters = static_cast<TcDriverParameters*>(a1); 
              __ASSERT_ALWAYS(tcDriverParameters!=NULL, Kern::Fault("DTraceCoreTestChannel::DoControl: NULL parameter!", __LINE__) );              
              DeactivateTrace(*tcDriverParameters, (TInt)(a2));
              return KErrNone;
              }
         case RTraceCoreTest::ERefreshActivations:
             {
//            Kern::Printf("DTraceCoreTestChannel::DoControl() RTraceCoreTest::ERefreshActivations");
             return RefreshActivations();
             }
              
         case RTraceCoreTest::EValidateFilterSync:
             {
//           Kern::Printf("DTraceCoreTestChannel::ReqDoControluest()  RTraceCoreTest::EValidateFilterSync");
             TcDriverParameters* tcDriverParameters = static_cast<TcDriverParameters*>(a1); 
             __ASSERT_ALWAYS(tcDriverParameters!=NULL, Kern::Fault("DTraceCoreTestChannel::DoControl: NULL parameter!", __LINE__) );             
             return ValidateFilterSync(*tcDriverParameters);
             }
             
         case RTraceCoreTest::EDropNextTrace:
             {
//           Kern::Printf("DTraceCoreTestChannel::DoControl()  RTraceCoreTest::EDropNextTrace");        
             DropNextTrace(TBool(a1));
             return KErrNone;
             }
         case RTraceCoreTest::ERegisterActivationNotification:
             {
//           Kern::Printf("DTraceCoreTestChannel::DoControl()  RTraceCoreTest::ERegisterActivationNotification");
             TcDriverParameters* tcDriverParameters = static_cast<TcDriverParameters*>(a1); 
             __ASSERT_ALWAYS(tcDriverParameters!=NULL, Kern::Fault("DTraceCoreTestChannel::DoControl: NULL parameter!", __LINE__) );
             RegisterActivationNotification(*tcDriverParameters, (TBool)(a2));
             return KErrNone;
             }       
         case RTraceCoreTest::ECheckActivationNotificationOk:
             {
//             Kern::Printf("DTraceCoreTestChannel::DoControl()  RTraceCoreTest::ECheckActivationNotificationOk");        
             return CheckActivationNotificationOk((TBool)(a1));
             }                  
            
         default:
             break;
              }
    return KErrNotSupported;
    }

TInt DTraceCoreTestChannel::DoRequest(TInt aId, TRequestStatus* aStatus, TAny* a1, TAny* a2)
    {
    switch(aId)
        {
        case RTraceCoreTest::ERequestTraceData:  // async request
            {                     
            iTraceDataRequestStatus   = aStatus;           
            if(a1)
                {
                TDes8* p = NULL;
                XTRAPD(r, XT_DEFAULT, kumemget(&p, &a1, sizeof(TAny*)); )                
                iTraceDataDestination = (r == KErrNone) ? p : NULL;                
                }
            
            iFrameCount = (a2) ? (TInt)a2 : 1;
            iFrameBuffer.Zero();
            
            return KErrNone;
                }
          
         default:
            break;
        }
    return KErrNotSupported;
    }

void DTraceCoreTestChannel::ActivateTrace(TcDriverParameters& aDriverParameters, TInt aNumTraces)
    {
    TcDriverParameters tcDriverParams;
    TInt ret = Kern::ThreadRawRead(iClient, (const TAny *)&aDriverParameters,(TAny*)&tcDriverParams, sizeof(TcDriverParameters) );
    __ASSERT_ALWAYS(KErrDied!=ret, Kern::Fault("DTraceCoreTestChannel::ActivateTrace: ThreadRawRead: iClient died!", __LINE__) );    
    
    NKern::ThreadEnterCS();
    for (TInt i=0; i<aNumTraces; i++)
        {
        DTraceActivationIf::ActivateTrace((tcDriverParams.iComponentId)+i,(tcDriverParams.iGroupId)+i);
        }
    NKern::ThreadLeaveCS();    
    }

void DTraceCoreTestChannel::DeactivateTrace(TcDriverParameters& aDriverParameters, TInt aNumTraces)
    {    
    TcDriverParameters tcDriverParams;    
    TInt ret = Kern::ThreadRawRead(iClient, (const TAny *)&aDriverParameters,(TAny*)&tcDriverParams, sizeof(TcDriverParameters) );
    __ASSERT_ALWAYS(KErrDied!=ret,Kern::Fault("DTraceCoreTestChannel::DeactivateTrace: ThreadRawRead: iClient died!", __LINE__) );

    NKern::ThreadEnterCS();    
    for (TInt i=0; i<aNumTraces; i++)
        {
        DTraceActivationIf::DeactivateTrace((tcDriverParams.iComponentId)+i,(tcDriverParams.iGroupId)+i);
        }
    NKern::ThreadLeaveCS();    
    }

TInt DTraceCoreTestChannel::RefreshActivations()
    {
    NKern::ThreadEnterCS();
    TInt err = DTraceActivationIf::RefreshActivations();
    NKern::ThreadLeaveCS();
    return err;
    }

/**
 * Validate that the BTrace::Filter matches the tracecore filters 
 * for all OST categories
 * 
 * returns KErrNone if filters match - KErrGeneral otherwise
 */
TInt  DTraceCoreTestChannel::ValidateFilterSync(TcDriverParameters& aDriverParameters)
    {
    TcDriverParameters tcDriverParams;
    TInt ret = Kern::ThreadRawRead(iClient, (const TAny *)&aDriverParameters,(TAny*)&tcDriverParams, sizeof(TcDriverParameters) );
    __ASSERT_ALWAYS(ret == KErrNone, Kern::Fault("DTraceCoreTestChannel::ValidateFilterSync: ThreadRawRead: iClient died!", __LINE__) );    
    
    TBool tcFilter = DTraceActivationIf::IsTraceActivated(tcDriverParams.iComponentId, tcDriverParams.iGroupId);
    TBool btFilter = BTrace::CheckFilter(tcDriverParams.iGroupId);                    
    if( tcFilter != btFilter)
        {
        ret = KErrGeneral;
        }            

    return ret;
    }

/**
 * Adds or removes a activation notification listener
 * 
 * returns KErrNone if filters match - KErrGeneral otherwise
 */
void DTraceCoreTestChannel::RegisterActivationNotification(TcDriverParameters& aDriverParameters, TBool aRegister)
    {
    TcDriverParameters tcDriverParams;
    TInt ret = Kern::ThreadRawRead(iClient, (const TAny *)&aDriverParameters,(TAny*)&tcDriverParams, sizeof(TcDriverParameters) );
    __ASSERT_ALWAYS(ret == KErrNone, Kern::Fault("DTraceCoreTestChannel::ValidateFilterSync: ThreadRawRead: iClient died!", __LINE__) );
        
    if (aRegister)
        {
        MTraceCoreNotificationReceiver::RegisterNotificationReceiver(tcDriverParams.iComponentId, tcDriverParams.iGroupId);
        }
    else
        {
        MTraceCoreNotificationReceiver::UnregisterNotificationReceiver(tcDriverParams.iComponentId, tcDriverParams.iGroupId);
        }
    }

/**
 * Add a activation notification listener, then activate a trace group and check if the activation  
 * has really happened when the notification arrives
 * 
 * returns KErrNone if filters match - KErrGeneral otherwise
 */
TInt DTraceCoreTestChannel::CheckActivationNotificationOk(TBool aShouldBeNotified)
    {
    TInt ret = KErrGeneral;
    
    // Everything OK if we should've got notification and we got and filters were in sync
    if (aShouldBeNotified && iNotificationReceived && iFilterInSyncWhenNotified)
        {
        ret = KErrNone;
        }
    
    // Everything OK if we should NOT got notification and we didn't
    else if (!aShouldBeNotified && !iNotificationReceived)
        {
        ret = KErrNone;
        }
    
    // Reset the variables for next test
    iFilterInSyncWhenNotified = EFalse;
    iNotificationReceived = EFalse;
    
    return ret;
    }

/**
 * Callback function from TraceCore when the trace is activated
 */
void DTraceCoreTestChannel::TraceActivated( TUint32 aComponentId, TUint16 aGroupId  )
    {
    TBool tcFilter = DTraceActivationIf::IsTraceActivated(aComponentId, aGroupId);
    iFilterInSyncWhenNotified = tcFilter;
    iNotificationReceived = ETrue;
    }

/**
 * Callback function from TraceCore when the trace is deactivated
 */
void DTraceCoreTestChannel::TraceDeactivated( TUint32 aComponentId, TUint16 aGroupId  )
    {
    TBool tcFilter = DTraceActivationIf::IsTraceActivated(aComponentId, aGroupId);
    iFilterInSyncWhenNotified = !tcFilter;
    iNotificationReceived = ETrue;
    }

/*
 * Tells the test writer that we don't actually want to 
 * send a trace... this is to test that the handlers
 * are formatting the data to include "missing" info.
 */
void DTraceCoreTestChannel::DropNextTrace(TBool aDrop)
    {
    iDropTrace=aDrop;
    }

DECLARE_STANDARD_LDD()
	{
	Kern::Printf("d_tracecore.ldd creating DTraceCoreTestFactory");
	return new DTraceCoreTestFactory;
	}