/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  

*

*/

#include <e32def.h>

#include <e32cmn.h>

#include <arm.h>

#include <kernel.h>

#include <kern_priv.h>

#include <nk_trace.h>

#include "MemoryEventHandler.h"

DMemoryEventHandler::DMemoryEventHandler(DProfilerSampleBuffer* aSampleBuffer)

    :   DKernelEventHandler(EventHandler, this), 

        iSampleBuffer(aSampleBuffer), 

        iSampleDescriptor(&(this->iSample[1]),0,256)

    {

//    Kern::Printf("DMemoryEventHandler::DMemoryEventHandler()");

    iCount = 0;

    iPreviousCount = 0;

    }

TInt DMemoryEventHandler::Create()

    {

//    Kern::Printf("DMemoryEventHandler::Create()");

    TInt err(Kern::MutexCreate(iLock, _L("MemoryEventHandlerLock"), KMutexOrdGeneral0));

    if (err != KErrNone)

        return err;

    return Add();

    }

DMemoryEventHandler::~DMemoryEventHandler()

    {

//    Kern::Printf("DMemoryEventHandler::~DMemoryEventHandler()");

    if (iLock)

        iLock->Close(NULL);

    }

TInt DMemoryEventHandler::Start()

    {

//    Kern::Printf("DMemoryEventHandler::Start()");

    iTracking = ETrue;

    return KErrNone;

    }

TInt DMemoryEventHandler::Stop()

    {

//    Kern::Printf("DMemoryEventHandler::Stop()");

    iTracking = EFalse;

    return KErrNone;

    }

TBool DMemoryEventHandler::SampleNeeded()

    {

    LOGTEXT("DMemoryEventHandler::SampleNeeded()");

    // increase the coutner by one on each round

    iCount++;

    // check if event handler was not running

//    if(!iTracking)

//        return false; // return false

    return true;

    }

TUint DMemoryEventHandler::EventHandler(TKernelEvent aType, TAny* a1, TAny* a2, TAny* aThis)

    {

    return ((DMemoryEventHandler*)aThis)->HandleEvent(aType, a1, a2);

    }

TUint DMemoryEventHandler::HandleEvent(TKernelEvent aType, TAny* a1, TAny* a2)

    {

    // debug

//    Kern::Printf("New kernel event received, %d", aType);

    if (iTracking/* && iCount != iPreviousCount*/)

        {

//        iPreviousCount = iCount;

        iCounters[aType]++;

        switch (aType)

            {

            // capture only chunk creation, updates and destroyal

            case EEventNewChunk:

                {

                DChunk* chunk = (DChunk*)a1;

                HandleAddChunk(chunk);

                break;

                }

            case EEventUpdateChunk:   

                HandleUpdateChunk((DChunk*)a1);

                break;

            case EEventDeleteChunk:      

                HandleDeleteChunk((DChunk*)a1);

                break;

//            case EEventAddProcess:

//                Kern::Printf("Process added: 0x%08x", (DProcess*)a1);

//                break;

//            case EEventUpdateProcess:

//                Kern::Printf("DProcess updated: 0x%08x", (DProcess*)a1);

//                break;

//            case EEventRemoveProcess:

//                Kern::Printf("DProcess removed: 0x%08x", (DProcess*)a1);

//                break;

//            case EEventAddCodeSeg:

//                Kern::Printf("DCodeSeg added: 0x%08x", (DCodeSeg*)a1);

//                break;

//            case EEventRemoveCodeSeg:

//                Kern::Printf("DCodeSeg deleted: 0x%08x", (DCodeSeg*)a1);

//                break;

            case EEventAddThread:

                HandleAddThread((DThread*)a1);

                break;

            case EEventUpdateThread:    // thread renaming

                HandleUpdateThread((DThread*)a1);

                break;

//            case EEventKillThread:

            case EEventRemoveThread:

                HandleDeleteThread((DThread*)a1);

                break;

#ifdef MEM_EVENT_HANDLER_LIBRARY_EVENTS

            case EEventAddLibrary:

                HandleAddLibrary((DLibrary*)a1, (DThread*)a2);

                break;

            case EEventRemoveLibrary:

                HandleDeleteLibrary((DLibrary*)a1);

                break;

#endif

            // ignore exception events

            case EEventSwExc:

            case EEventHwExc:

            default:

                break;

            }

        }

//    else if(iTracking && iCount == iPreviousCount)

//        {

//        // if time stamp is not updated profiling has stopped

//        Stop();

//        }

    return DKernelEventHandler::ERunNext;

    }

TInt DMemoryEventHandler::EncodeNameCode()

    {

    iSample[0] = 1;

    iSample[1] = 0xaa;

    return 2;

    }

// encode mark for new chunk or thread

TInt DMemoryEventHandler::EncodeNewCode()

    {

    iSample[0] = 1;

    iSample[1] = 0xda;

    return 2;

    }

// encode mark for update of chunk or thread

TInt DMemoryEventHandler::EncodeUpdateCode()

    {

    iSample[0] = 1;

    iSample[1] = 0xdb;

    return 2;

    }

// encode mark for removal of chunk or thread

TInt DMemoryEventHandler::EncodeRemoveCode()

    {

    iSample[0] = 1;

    iSample[1] = 0xdc;

    return 2;

    }

// encode the memory sample header in all memory changes

TInt DMemoryEventHandler::AddHeader()

    {

    TInt err(KErrNone);

    TUint8 number(4);    // mem sampler id

    // check if iCount bigger than previous, i.e. at least 1 ms has passed from the previous sample

    if(iCount > iPreviousCount)

        {

        err = this->iSampleBuffer->AddSample(&number,1);

        err = this->iSampleBuffer->AddSample((TUint8*)&(iCount),4);

        // add data chunk header

        TInt length(EncodeUpdateCode());

        err = iSampleBuffer->AddSample(iSample, length);

        // add total memory sample in the beginning of each sample

        length = EncodeTotalMemory();

        err = iSampleBuffer->AddSample(iSample, length);

        AddFooter();    // end mark for total memory sample

        }

    iPreviousCount = iCount;

    // add actual sample

    err = this->iSampleBuffer->AddSample(&number,1);

    err = this->iSampleBuffer->AddSample((TUint8*)&(iCount),4);

    return err;

    }

// encode the memory sample header in all memory changes

TInt DMemoryEventHandler::AddFooter()

    {

    TInt err(KErrNone);

    TUint8 number(0);    // end mark

    err = this->iSampleBuffer->AddSample(&number,1);

    return err;

    }

TInt DMemoryEventHandler::EncodeTotalMemory()

    {   

    TUint8* size(&iSample[0]);

    *size = 0;

    NKern::LockSystem();

    TInt freeRam(Kern::FreeRamInBytes());

    TInt totalRam(Kern::SuperPage().iTotalRamSize);

    NKern::UnlockSystem();

    iSampleDescriptor.Zero();

    TUint32 id(0xbabbeaaa);

    TInt zero(0);

    iSampleDescriptor.Append((TUint8*)&(id),sizeof(TUint32));

    *size += sizeof(TUint);

    iSampleDescriptor.Append((TUint8*)&(totalRam),sizeof(TInt));

    *size += sizeof(TInt);

    // append the cell amount allocated

    iSampleDescriptor.Append((TUint8*)&(zero),sizeof(TInt));

    *size += sizeof(TInt);

    // append the chunk size

    iSampleDescriptor.Append((TUint8*)&(freeRam),sizeof(TInt));

    *size += sizeof(TInt);

    // append the thread user stack size

    iSampleDescriptor.Append((TUint8*)&(zero),sizeof(TInt));

    *size += sizeof(TInt);

    return ((TInt)(*size))+1;

    }

// handle chunk activity

TBool DMemoryEventHandler::HandleAddChunk(DChunk* aChunk)

    {    

//    Kern::Printf("New DChunk created: 0x%08x, time: %d", aChunk, iCount);

    NKern::ThreadEnterCS();

    Kern::MutexWait(*iLock);

    // add header first

    TInt err(AddHeader());

    if(err != KErrNone)

        {

        return EFalse;

        }

    // new chunk, add name of it

    TInt length(EncodeNameCode());

    iSampleBuffer->AddSample(iSample, length);

    // new chunk, add name of it

    length = EncodeChunkName(*aChunk);

    iSampleBuffer->AddSample(iSample, length);

    // add new chunk tag

    length = EncodeNewCode();

    iSampleBuffer->AddSample(iSample, length);

    length = EncodeChunkData(*aChunk);

    iSampleBuffer->AddSample(iSample, length);

    // add end mark

    AddFooter();

    Kern::MutexSignal(*iLock);

    NKern::ThreadLeaveCS();

    return ETrue;

    }

TBool DMemoryEventHandler::HandleUpdateChunk(DChunk* aChunk)

    {

//    Kern::Printf("DChunk updated: 0x%08x, time: %d", aChunk, iCount);

    NKern::ThreadEnterCS();

    Kern::MutexWait(*iLock);

    // add header first

    TInt err(AddHeader());

    if(err != KErrNone)

        {

        return EFalse;

        }

    // add new chunk tag

    TInt length(EncodeUpdateCode());

    iSampleBuffer->AddSample(iSample, length);

    length = EncodeChunkData(*aChunk);

    iSampleBuffer->AddSample(iSample, length);

    // add end mark

    AddFooter();

    Kern::MutexSignal(*iLock);

    NKern::ThreadLeaveCS();

    return ETrue;

    }

TBool DMemoryEventHandler::HandleDeleteChunk(DChunk* aChunk)

    {

//    Kern::Printf("DChunk deleted: 0x%08x, time: %d", aChunk, iCount);

    NKern::ThreadEnterCS();

    Kern::MutexWait(*iLock);

    // add header first

    TInt err(AddHeader());

    if(err != KErrNone)

        {

        return EFalse;

        }

    // add new chunk tag

    TInt length(EncodeRemoveCode());

    iSampleBuffer->AddSample(iSample, length);

    length = EncodeChunkData(*aChunk);

    iSampleBuffer->AddSample(iSample, length);

    // add end mark

    AddFooter();

    Kern::MutexSignal(*iLock);

    NKern::ThreadLeaveCS();

    return ETrue;

    }

// handle process activity

TBool DMemoryEventHandler::HandleAddProcess(DProcess *aProcess)

    {

    return ETrue;

    }

TBool DMemoryEventHandler::HandleUpdateProcess(DProcess *aProcess)

    {

    return ETrue;

    }

TBool DMemoryEventHandler::HandleDeleteProcess(DProcess *aProcess)

    {

    return ETrue;

    }

// handle thread activity

TBool DMemoryEventHandler::HandleAddThread(DThread* aThread)

    {

//    Kern::Printf("DThread added: 0x%08x, time: %d", aThread->iId, iCount);

    NKern::ThreadEnterCS();

    Kern::MutexWait(*iLock);

    // add header first

    TInt err(AddHeader());

    if(err != KErrNone)

        {

        return EFalse;

        }

    // new thread, add name of it

    TInt length(EncodeNameCode());

    iSampleBuffer->AddSample(iSample, length);

    // new chunk, add name of it

    length = EncodeChunkName(*aThread);

    iSampleBuffer->AddSample(iSample, length);

    // add new chunk tag

    length = EncodeNewCode();

    iSampleBuffer->AddSample(iSample, length);

    length = EncodeChunkData(*aThread);

    iSampleBuffer->AddSample(iSample, length);

    // add end mark

    AddFooter();

    Kern::MutexSignal(*iLock);

    NKern::ThreadLeaveCS();

    return ETrue;

    }

TBool DMemoryEventHandler::HandleUpdateThread(DThread* aThread)

    {

//    Kern::Printf("DThread updated: 0x%08x, time: %d", aThread->iId, iCount);

    NKern::ThreadEnterCS();

    Kern::MutexWait(*iLock);

    // add header first

    TInt err(AddHeader());

    if(err != KErrNone)

        {

        return EFalse;

        }

    // add new chunk tag

    TInt length(EncodeUpdateCode());

    iSampleBuffer->AddSample(iSample, length);

    length = EncodeChunkData(*aThread);

    iSampleBuffer->AddSample(iSample, length);

    // add end mark

    AddFooter();

    Kern::MutexSignal(*iLock);

    NKern::ThreadLeaveCS();    

    return ETrue;

    }

TBool DMemoryEventHandler::HandleDeleteThread(DThread* aThread)

    {

//    Kern::Printf("DThread deleted: 0x%08x, time: %d", aThread->iId, iCount);

    NKern::ThreadEnterCS();

    Kern::MutexWait(*iLock);

    // add header first

    TInt err(AddHeader());

    if(err != KErrNone)

        {

        return EFalse;

        }

    // add new chunk tag

    TInt length(EncodeRemoveCode());

    iSampleBuffer->AddSample(iSample, length);

    length = EncodeChunkData(*aThread);

    iSampleBuffer->AddSample(iSample, length);

    // add end mark

    AddFooter();

    Kern::MutexSignal(*iLock);

    NKern::ThreadLeaveCS();  

    return ETrue;

    }

TBool DMemoryEventHandler::HandleAddLibrary(DLibrary* aLibrary, DThread* aThread)

    {

    LOGTEXT("DMemoryEventHandler::HandleAddLibrary");

    Kern::Printf("DLibrary added: 0x%08x, time: %d", aLibrary, iCount);

    // add header first

    NKern::ThreadEnterCS();

    Kern::MutexWait(*iLock);

    TInt err(AddHeader());

    if(err != KErrNone)

        {

        return EFalse;

        }

    // new library, add name of it

    TInt length(EncodeNameCode());

    iSampleBuffer->AddSample(iSample, length);

    // new chunk, add name of it

    length = EncodeChunkName(*aLibrary);

    iSampleBuffer->AddSample(iSample, length);

    // add new chunk tag

    length = EncodeNewCode();

    iSampleBuffer->AddSample(iSample, length);

    length = EncodeChunkData(*aLibrary, *aThread);

    iSampleBuffer->AddSample(iSample, length);

    // add end mark

    AddFooter();

    Kern::MutexSignal(*iLock);

    NKern::ThreadLeaveCS();      

    return ETrue;

    }

TBool DMemoryEventHandler::HandleDeleteLibrary(DLibrary* aLibrary)

    {

    Kern::Printf("DLibrary deleted: 0x%08x, time: %d", aLibrary, iCount);

    NKern::ThreadEnterCS();

    Kern::MutexWait(*iLock);

    // add header first

    TInt err(AddHeader());

    if(err != KErrNone)

        {

        return EFalse;