/*

* 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 "MemSpyDriverOSAdaption.h"

// System includes

#include <kern_priv.h>

#include <nkern.h>

#include <nk_plat.h>

#ifdef __MARM__

#include <arm.h>

#endif

// I've removed UNALIGNED_DATA_MEMBER in preference for just using memcpy to get round the potential unaligned access. -TomS

// User includes

#include "MemSpyDriverLog.h"

#include "MemSpyDriverPAndS.h"

#include "MemSpyDriverDevice.h"

// Internal constants

const TInt KMemSpyLocalThreadDataSizeEstimate = 0x80; // The amount of user stack that MemSpy attempts to scan for the RHeaep vTable

DMemSpyDriverOSAdaptionDObject::DMemSpyDriverOSAdaptionDObject( DMemSpyDriverOSAdaption& aOSAdaption )

:   iOSAdaption( aOSAdaption )

    {

    }

TUint8 DMemSpyDriverOSAdaptionDObject::GetContainerID( DObject& aObject ) const

    {

    return aObject.iContainerID;

    }

TObjectType DMemSpyDriverOSAdaptionDObject::GetObjectType( DObject& aObject ) const

    {

    const TUint8 containerId = GetContainerID( aObject );

    const TObjectType ret = static_cast< TObjectType >( containerId - 1 );

    return ret;

    }

DObject* DMemSpyDriverOSAdaptionDObject::GetOwner( DObject& aObject ) const

    {

    return aObject.iOwner;

    }

DObject* DMemSpyDriverOSAdaptionDObject::GetOwner( DObject& aObject, TUint8 aExpectedContainerId ) const

    {

    DObject* owner = GetOwner( aObject );

    //

    const TUint8 containerId = GetContainerID( aObject ) - 1;

    if ( containerId != aExpectedContainerId )

        {

        owner = NULL;

        }

    //

    return owner;

    }

TInt DMemSpyDriverOSAdaptionDObject::GetAccessCount( DObject& aObject ) const

    {

    return aObject.AccessCount();

    }

TInt DMemSpyDriverOSAdaptionDObject::GetUniqueID( DObject& aObject ) const

    {

    return aObject.UniqueID();

    }

TUint DMemSpyDriverOSAdaptionDObject::GetProtection( DObject& aObject ) const

    {

    return aObject.Protection();

    }

TUint8* DMemSpyDriverOSAdaptionDObject::GetAddressOfKernelOwner( DObject& aObject ) const

    {

    return (TUint8*)aObject.Owner();

    }

DMemSpyDriverOSAdaptionDThread::DMemSpyDriverOSAdaptionDThread( DMemSpyDriverOSAdaption& aOSAdaption )

:   DMemSpyDriverOSAdaptionDObject( aOSAdaption )

    {

    // Get current NThread and map it on to DThread

    NThread* nThread = NKern::CurrentThread();

    TRACE( Kern::Printf( "DMemSpyDriverOSAdaptionDThread::Construct() - nThread: 0x%08x", nThread ) );

    DThread* dThread = Kern::NThreadToDThread( nThread );

    TRACE( Kern::Printf( "DMemSpyDriverOSAdaptionDThread::Construct() - dThread: 0x%08x", dThread ) );

    // At this point, it should be possible to work out the offset of the NThread within DThread.

    iOffset_NThread = reinterpret_cast<TUint32>( nThread ) - reinterpret_cast<TUint32>( dThread );

    TRACE( Kern::Printf( "DMemSpyDriverOSAdaptionDThread::Construct() - difference: 0x%08x", iOffset_NThread ) );

    // Work out the delta between compile time and run time

    TInt delta = iOffset_NThread - _FOFF( DThread, iNThread );

    TRACE( Kern::Printf( "DMemSpyDriverOSAdaptionDThread::Construct() - compile time vs run time offset delta: %d", delta ));

    // iNThread

    TRACE( Kern::Printf( "OSA - [DThread::iNThread]              compile time offset: 0x%08x, run time offset: 0x%08x", _FOFF(DThread,iNThread), iOffset_NThread ));

    // iExitType

    iOffset_ExitType = _FOFF( DThread, iExitType ) + delta;

    TRACE( Kern::Printf( "OSA - [DThread::iExitType]             compile time offset: 0x%08x, run time offset: 0x%08x", _FOFF(DThread,iExitType), iOffset_ExitType ));

    // iSupervisorStack

    iOffset_SupervisorStackBase = _FOFF( DThread, iSupervisorStack ) + delta;

    TRACE( Kern::Printf( "OSA - [DThread::iSupervisorStack]      compile time offset: 0x%08x, run time offset: 0x%08x", _FOFF(DThread,iSupervisorStack), iOffset_SupervisorStackBase ));

    // iSupervisorStackSize

    iOffset_SupervisorStackSize = _FOFF( DThread, iSupervisorStackSize ) + delta;

    TRACE( Kern::Printf( "OSA - [DThread::iSupervisorStackSize]  compile time offset: 0x%08x, run time offset: 0x%08x", _FOFF(DThread,iSupervisorStackSize), iOffset_SupervisorStackSize ));

    }

NThread* DMemSpyDriverOSAdaptionDThread::GetNThread( DThread& aObject ) const

    {

    DThread* dThread = &aObject;

    TUint32 pTarget = reinterpret_cast<TUint32>( dThread ) + iOffset_NThread;

    NThread* pRet = reinterpret_cast< NThread* >( pTarget );

    TRACE( Kern::Printf( "DMemSpyDriverOSAdaptionDThread::GetNThread() - aObject: 0x%08x, ret: 0x%08x", &aObject, pRet ) );

    return pRet;

    }

TExitType DMemSpyDriverOSAdaptionDThread::GetExitType( DThread& aObject ) const

    {

    DThread* dThread = &aObject;

    TUint32 pTarget = reinterpret_cast<TUint32>( dThread ) + iOffset_ExitType;

	TUint8 exitType = *reinterpret_cast<TUint8*>(pTarget);

    TRACE( Kern::Printf( "DMemSpyDriverOSAdaptionDThread::GetExitType() - aObject: 0x%08x, ret: %d", &aObject, (TInt)exitType ) );

    return (TExitType)exitType;

    }

TUint32 DMemSpyDriverOSAdaptionDThread::GetSupervisorStackBase( DThread& aObject ) const

    {

    DThread* dThread = &aObject;

    TUint32 pTarget = reinterpret_cast<TUint32>( dThread ) + iOffset_SupervisorStackBase;

	TUint32 ret;

	memcpy(&ret, (const TAny*)pTarget, sizeof(TUint32));

    TRACE( Kern::Printf( "DMemSpyDriverOSAdaptionDThread::GetSupervisorStackBase() - aObject: 0x%08x, ret: 0x%08x", &aObject, ret ) );

    return ret;

    }

TInt DMemSpyDriverOSAdaptionDThread::GetSupervisorStackSize( DThread& aObject ) const

    {

    DThread* dThread = &aObject;

    TUint32 pTarget = reinterpret_cast<TUint32>( dThread ) + iOffset_SupervisorStackSize;

	TInt ret;

	memcpy(&ret, (const TAny*)pTarget, sizeof(TInt));

    TRACE( Kern::Printf( "DMemSpyDriverOSAdaptionDThread::GetSupervisorStackSize() - aObject: 0x%08x, ret: %d", &aObject, ret ) );

    return ret;

    }

RAllocator* DMemSpyDriverOSAdaptionDThread::GetAllocator( DThread& aObject ) const

    {

    TRACE( Kern::Printf( "DMemSpyDriverOSAdaptionDThread::GetAllocator() - START" ) );

    //

    RAllocator* ret = aObject.iAllocator;

    TRACE( Kern::Printf( "DMemSpyDriverOSAdaptionDThread::GetAllocator() - allocator: 0x%08x", ret ) );

    //

    if  ( ret == NULL )

        {

        TUint32 stackAddress = 0;

        ret = GetAllocatorAndStackAddress( aObject, stackAddress );

        }

    //

    TRACE( Kern::Printf( "DMemSpyDriverOSAdaptionDThread::GetAllocator() - END - ret: 0x%08x", ret ) );

    return ret;

    }

CActiveScheduler* DMemSpyDriverOSAdaptionDThread::GetActiveScheduler( DThread& aObject ) const

    {

    TRACE( Kern::Printf( "DMemSpyDriverOSAdaptionDThread::GetActiveScheduler() - START" ) );

    CActiveScheduler* ret = aObject.iScheduler;

    //

    TRACE( Kern::Printf( "DMemSpyDriverOSAdaptionDThread::GetActiveScheduler() - scheduler: 0x%08x", ret ) );

    if  ( ret == NULL )

        {

        // We need the stack address of the heap in order to locate the active scheduler.

        // Implicitly this means that MemSpy can only list active scheduler contents for threads

        // that use a default RHeap. This has always been the case, so this is not a functional break.

        //

        // Assumed stack layout is something like this:

        // 

        // stack[0x00403ffc] 0x00000000, vTable: 0x00000000 (offset: 0004)

        // stack[0x00403ff8] 0x00000000, vTable: 0x00000000 (offset: 0008)

        // stack[0x00403ff4] 0x00000002, vTable: 0x00000000 (offset: 0012)

        // stack[0x00403ff0] 0x00000002, vTable: 0x00000000 (offset: 0016)

        // stack[0x00403fec] 0x00000000, vTable: 0x00000000 (offset: 0020)

        // stack[0x00403fe8] 0x0000000c, vTable: 0x00000000 (offset: 0024)

        // stack[0x00403fe4] 0x00600078, vTable: 0x80228938 (offset: 0028)

        // stack[0x00403fe0] 0x00000001, vTable: 0x00000000 (offset: 0032)

        // stack[0x00403fdc] 0x00600000, vTable: 0x80268430 (offset: 0036)		TLocalThreadData::iTlsHeap       RAllocator*		  80268428    0034    vtable for RHeap

        // stack[0x00403fd8] 0x0060009c, vTable: 0x80268394 (offset: 0040)		TLocalThreadData::iTrapHandler   TTrapHandler		  8026838c    0014    vtable for TCleanupTrapHandler

        // stack[0x00403fd4] 0x00600110, vTable: 0x802682ec (offset: 0044)		TLocalThreadData::iScheduler     CActiveScheduler*	  802682e4    002c    vtable for CActiveScheduler

        // stack[0x00403fd0] 0x00600000, vTable: 0x80268430 (offset: 0048)      TLocalThreadData::iHeap          RAllocator*          80268428    0034    vtable for RHeap

        // stack[0x00403fcc] 0x00000000, vTable: 0x00000000 (offset: 0052)

        // stack[0x00403fc8] 0x00100000, vTable: 0x00000000 (offset: 0056)

        //

        // GetAllocatorAndStackAddress() will return the first RHeap* it finds, so this will be iTlsHeap, which

        // is actually no bad thing as it will hopefully be initialised using an RHeap pointer.

        // CActiveScheduler* is 8 bytes further on from that.

        //

        const TUint32 KOffsetToCActiveScheduler = 8;

        // 

        TUint32 stackAddress = 0;

        RAllocator* allocator = GetAllocatorAndStackAddress( aObject, stackAddress );

        TRACE( Kern::Printf( "DMemSpyDriverOSAdaptionDThread::GetActiveScheduler() - allocator: 0x%08x, stackAddress: 0x%08x", allocator, stackAddress ) );

        // This assumes the layout of the thread local data structure, i.e. that the four bytes that follow the

        // allocator pointer are always the active scheduler pointer.

        if  ( allocator != NULL && stackAddress > 0 )

            {

            TUint32* ptr = reinterpret_cast< TUint32* >( stackAddress - KOffsetToCActiveScheduler );

            const TInt r = Kern::ThreadRawRead( &aObject, ptr, &ret, sizeof( ret ) );

            TRACE( Kern::Printf( "DMemSpyDriverOSAdaptionDThread::GetActiveScheduler() - stack address containing scheduler pointer: 0x%08x, read result: %d, CActiveScheduler*: 0x%08x", ptr, r, ret ) );

            if  ( r != KErrNone )

                {

                ret = NULL;

                }

            }

        }

    //

    TRACE( Kern::Printf( "DMemSpyDriverOSAdaptionDThread::GetActiveScheduler() - END - ret: 0x%08x", ret ) );

    return ret;

    }

TUint32 DMemSpyDriverOSAdaptionDThread::GetUserStackBase( DThread& aObject ) const

    {

    return aObject.iUserStackRunAddress;

    }

TInt DMemSpyDriverOSAdaptionDThread::GetUserStackSize( DThread& aObject ) const

    {

    return aObject.iUserStackSize;

    }

DProcess* DMemSpyDriverOSAdaptionDThread::GetOwningProcess( DThread& aObject ) const

    {

    return aObject.iOwningProcess;

    }

TUint DMemSpyDriverOSAdaptionDThread::GetId( DThread& aObject ) const

    {

    return aObject.iId;

    }

MemSpyObjectIx* DMemSpyDriverOSAdaptionDThread::GetHandles( DThread& aObject ) const

    {

    MemSpyObjectIx* handles = MemSpyObjectIx_GetHandlePointer_Thread( aObject );

    return handles;

    }

TUint DMemSpyDriverOSAdaptionDThread::GetOwningProcessId( DThread& aObject ) const

    {

    DProcess* process = GetOwningProcess( aObject );

    TUint ret = 0;

    //

    if  ( process )

        {

        ret = OSAdaption().DProcess().GetId( *process );

        }

    //

    return ret;

    }

TInt DMemSpyDriverOSAdaptionDThread::GetPriority( DThread& aObject ) const

    {

    return aObject.iThreadPriority;

    }

TUint8* DMemSpyDriverOSAdaptionDThread::GetAddressOfOwningProcess( DThread& aObject ) const

    {

    return (TUint8*)aObject.iOwningProcess;

    }

void DMemSpyDriverOSAdaptionDThread::GetNameOfOwningProcess( DThread& aObject, TDes& aName ) const

    {

    if  ( aObject.iOwningProcess )

        {

        aObject.iOwningProcess->FullName( aName );

        }

    }

RAllocator* DMemSpyDriverOSAdaptionDThread::GetAllocatorAndStackAddress( DThread& aObject, TUint32& aStackAddress ) const

    {

    TRACE( Kern::Printf( "DMemSpyDriverOSAdaptionDThread::GetAllocatorAndStackAddress() - START" ) );

    //

    aStackAddress = 0;

    RAllocator* ret = NULL;

    // We will assume the thread is running and that the user-side stack has been set up

    // accordingly.

    const TUint32 base = GetUserStackBase( aObject );

    const TInt size = GetUserStackSize( aObject );

    TRACE( Kern::Printf( "DMemSpyDriverOSAdaptionDThread::GetAllocatorAndStackAddress() - base: 0x%08x, size: %d, KMemSpyLocalThreadDataSizeEstimate: %d", base, size, KMemSpyLocalThreadDataSizeEstimate ) );

    const TUint32 top = base + size;

    // This is the RHeap vtable we are looking for

    const TUint32 rHeapVTable = OSAdaption().Device().RHeapVTable();

    TRACE( Kern::Printf( "DMemSpyDriverOSAdaptionDThread::GetAllocatorAndStackAddress() - rHeapVTable: 0x%08x", rHeapVTable ) );

    //

    TInt r = KErrNone;

#ifdef TRACE_TYPE_GENERAL 

    for( TUint32 addr = top - 4; addr >= top - KMemSpyLocalThreadDataSizeEstimate; addr -= 4 )

        {

        TUint32 value = 0;

        TUint32 possibleVTable = 0;

        //

        TUint32* ptr = reinterpret_cast< TUint32* >( addr );

        //

        r = Kern::ThreadRawRead( &aObject, ptr, &value, sizeof( value ) );

        if  ( r == KErrNone )

            {

            Kern::ThreadRawRead( &aObject, reinterpret_cast< const TAny* >( value ), &possibleVTable, sizeof( possibleVTable ) );

            }

        TRACE( Kern::Printf( "DMemSpyDriverOSAdaptionDThread::GetAllocatorAndStackAddress() - stack[0x%08x] 0x%08x, vTable: 0x%08x (offset: %04d)", addr, value, possibleVTable, top - addr ) );

        }

#endif

    for( TUint32 addr = top - 4; addr >= top - KMemSpyLocalThreadDataSizeEstimate; addr -= 4 )

        {

        TRACE( Kern::Printf( "DMemSpyDriverOSAdaptionDThread::GetAllocatorAndStackAddress() - addr to read from: 0x%08x", addr ) );

        TUint32 value = 0;

        //

        TUint32* ptr = reinterpret_cast< TUint32* >( addr );

        //

        r = Kern::ThreadRawRead( &aObject, ptr, &value, sizeof( value ) );

        TRACE( Kern::Printf( "DMemSpyDriverOSAdaptionDThread::GetAllocatorAndStackAddress() - read from: 0x%08x, result: %d, value: 0x%08x", addr, r, value ) );

        //

        if  ( r == KErrNone )

            {

            // Try and read from the address which is now stored within 'value'. We must do this because 

            // the TLD class holds an RAllocator* and we need to ascertain the vTable of the RAllocator* matches the

            // only supported vTable that MemSpy understands (RHeap*).

            TUint32 possibleVTable = 0;

            r = Kern::ThreadRawRead( &aObject, reinterpret_cast< const TAny* >( value ), &possibleVTable, sizeof( possibleVTable ) );

            TRACE( Kern::Printf( "DMemSpyDriverOSAdaptionDThread::GetAllocatorAndStackAddress() - possible vtable read from: 0x%08x, result: %d, possibleVTable: 0x%08x", value, r, possibleVTable ) );

            if  ( r == KErrNone && possibleVTable == rHeapVTable )

                {

                aStackAddress = addr;

                ret = reinterpret_cast< RAllocator* >( value );

                break;

                }

            }

        }

    //

    TRACE( Kern::Printf( "DMemSpyDriverOSAdaptionDThread::GetAllocatorAndStackAddress() - END - ret: 0x%08x, aStackAddress: 0x%08x", ret, aStackAddress ) );

    return ret;

    }    

TBool DMemSpyDriverOSAdaptionDThread::IsHandleIndexValid( DThread& aObject ) const

    {

    MemSpyObjectIx* handles = MemSpyObjectIx_GetHandlePointer_Thread( aObject );

    return ( handles != NULL );

    }

DMemSpyDriverOSAdaptionDProcess::DMemSpyDriverOSAdaptionDProcess( DMemSpyDriverOSAdaption& aOSAdaption )

:   DMemSpyDriverOSAdaptionDObject( aOSAdaption )

    {

    }

TUint DMemSpyDriverOSAdaptionDProcess::GetId( DProcess& aObject ) const

    {

    TRACE( Kern::Printf( "DMemSpyDriverOSAdaptionDProcess::GetId() - value: %d", aObject.iId ) );

    return aObject.iId;

    }

MemSpyObjectIx* DMemSpyDriverOSAdaptionDProcess::GetHandles( DProcess& aObject ) const

    {

    MemSpyObjectIx* handles = MemSpyObjectIx_GetHandlePointer_Process( aObject );

    return handles;

    }

TExitType DMemSpyDriverOSAdaptionDProcess::GetExitType( DProcess& aObject ) const

    {

    return static_cast< TExitType >( aObject.iExitType );

    }

DThread* DMemSpyDriverOSAdaptionDProcess::OpenFirstThread( DProcess& aProcess ) const

    {

	// It appears that the system lock needs to be held while manipulating the iThreadQ

	DThread* result = NULL;

	NKern::LockSystem();

	// We don't use DProcess::FirstThread() as that doesn't appear to do any checking of whether the list is empty, ie if there are no threads at all

	SDblQueLink* threadLink = aProcess.iThreadQ.First();

	if (threadLink != NULL && threadLink != &aProcess.iThreadQ.iA)

		{

		result = _LOFF(threadLink,DThread,iProcessLink);

		if (result->Open() != KErrNone)

			{

			result = NULL;

			}

		}

	NKern::UnlockSystem();

    return result;

    }

TUint32 DMemSpyDriverOSAdaptionDProcess::GetSID( DProcess& aObject ) const

    {

    return GetSecurityInfo( aObject ).iSecureId;

    }

TUint DMemSpyDriverOSAdaptionDProcess::GetSecurityZone( DProcess& aObject ) const

    {

    return aObject.iSecurityZone;

    }

SSecurityInfo& DMemSpyDriverOSAdaptionDProcess::GetSecurityInfo( DProcess& aObject ) const

    {

    return aObject.iS;

    }

TInt DMemSpyDriverOSAdaptionDProcess::GetFlags( DProcess& aObject ) const

    {

    return aObject.iFlags;

    }

TInt DMemSpyDriverOSAdaptionDProcess::GetGeneration( DProcess& aObject ) const

    {

    return aObject.iGeneration;

    }

SDblQue& DMemSpyDriverOSAdaptionDProcess::GetThreadQueue( DProcess& aObject ) const

    {

    return aObject.iThreadQ;

    }

DThread* DMemSpyDriverOSAdaptionDProcess::GetThread( SDblQueLink* aLink ) const

    {

	DThread* ret = _LOFF( aLink, DThread, iProcessLink );

    return ret;

    }

void DMemSpyDriverOSAdaptionDProcess::SetSID( DProcess& aObject, TUint32 aSID ) const

    {

    GetSecurityInfo( aObject ).iSecureId = aSID;

    }

void DMemSpyDriverOSAdaptionDProcess::SetSecurityZone( DProcess& aObject, TUint aSecurityZone ) const

    {

    aObject.iSecurityZone = aSecurityZone;

    }

TBool DMemSpyDriverOSAdaptionDProcess::IsHandleIndexValid( DProcess& aObject ) const

    {

    MemSpyObjectIx* handles = MemSpyObjectIx_GetHandlePointer_Process( aObject );

    return ( handles != NULL );

    }

TUint DMemSpyDriverOSAdaptionDProcess::GetCreatorId( DProcess& aObject ) const

    {