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

// Shared includes
#include "MemSpyDriverOpCodes.h"
#include <memspy/driver/memspydriverobjectsshared.h>
#include "MemSpyDriverObjectsInternal.h"

// User includes
#include "MemSpyDriverUtils.h"
#include "MemSpyDriverDevice.h"
#include "MemSpyDriverOSAdaption.h"


DMemSpyDriverLogChanContainerBase::DMemSpyDriverLogChanContainerBase( DMemSpyDriverDevice& aDevice, DThread& aThread )
:   DMemSpyDriverLogChanBase( aDevice, aThread )
    {
	TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::DMemSpyDriverLogChanContainerBase() - this: 0x%08x", this ));
    }


DMemSpyDriverLogChanContainerBase::~DMemSpyDriverLogChanContainerBase()
	{
	TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::~DMemSpyDriverLogChanContainerBase() - START - this: 0x%08x", this ));

    ResetTempHandles();

	TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::~DMemSpyDriverLogChanContainerBase() - END - this: 0x%08x", this ));
	}









DObject* DMemSpyDriverLogChanContainerBase::CheckIfObjectIsInContainer( TMemSpyDriverContainerType aContainerType, DObject* aSearchFor, TBool aQuick )
    {
	__ASSERT_DEBUG( aSearchFor != NULL, MemSpyDriverUtils::Fault( __LINE__ ) );
    const TObjectType expectedType = ObjectTypeFromMemSpyContainerType( aContainerType );
    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::CheckIfObjectIsInContainer - START - aSearchFor: 0x%08x, expectedType: %d", aSearchFor, expectedType ));

    DObject* ret = NULL;
    
    // Quick mode means we just check container ids and we trust that the object
    // will exist.
    if ( aQuick )
        {
        const TObjectType objectType = OSAdaption().DThread().GetObjectType( *aSearchFor );
        TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::CheckIfObjectIsInContainer - aSearchFor.iContainerID: %d", objectType ) );
        if  ( objectType == expectedType )
            {
            ret = aSearchFor;
            }
        }
    else
        {
        // Full check to see if the specified object is part of the container
        DObjectCon* container = Kern::Containers()[ expectedType ];
        container->Wait();
        NKern::LockSystem();

        const TInt count = container->Count();
        for(TInt i=0; i<count; i++)
            {
            DObject* object = (*container)[ i ];

            // Do the two match?
            if  ( object == aSearchFor )
                {
                TRACE( Kern::Printf("    found match: %O", object));

                ret = object;
                break;
                }
            }

        NKern::UnlockSystem();
        container->Signal();
        }

    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::CheckIfObjectIsInContainer - END - ret: 0x%08x", ret ));
    TRACE( Kern::Printf(" ") );
    return ret;
    }



TObjectType DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType( TMemSpyDriverContainerType aType )
    {
    // Map type
    TObjectType type = EObjectTypeAny;
    switch( aType )
        {
    case EMemSpyDriverContainerTypeThread:
 	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeThread" ));
        type = EThread;
        break;
    case EMemSpyDriverContainerTypeProcess:
 	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeProcess" ));
        type = EProcess;
        break;
    case EMemSpyDriverContainerTypeChunk:
 	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeChunk" ));
        type = EChunk;
        break;
    case EMemSpyDriverContainerTypeLibrary:
 	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeLibrary" ));
        type = ELibrary;
        break;
    case EMemSpyDriverContainerTypeSemaphore:
 	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeSemaphore" ));
        type = ESemaphore;
        break;
    case EMemSpyDriverContainerTypeMutex:
 	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeMutex" ));
        type = EMutex;
        break;
    case EMemSpyDriverContainerTypeTimer:
 	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeTimer" ));
        type = ETimer;
        break;
    case EMemSpyDriverContainerTypeServer:
 	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeServer" ));
        type = EServer;
        break;
    case EMemSpyDriverContainerTypeSession:
 	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeSession" ));
        type = ESession;
        break;
    case EMemSpyDriverContainerTypeLogicalDevice:
 	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeLogicalDevice" ));
        type = ELogicalDevice;
        break;
    case EMemSpyDriverContainerTypePhysicalDevice:
 	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypePhysicalDevice" ));
        type = EPhysicalDevice;
        break;
    case EMemSpyDriverContainerTypeLogicalChannel:
 	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeLogicalChannel" ));
        type = ELogicalChannel;
        break;
    case EMemSpyDriverContainerTypeChangeNotifier:
 	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeChangeNotifier" ));
        type = EChangeNotifier;
        break;
    case EMemSpyDriverContainerTypeUndertaker:
 	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeUndertaker" ));
        type = EUndertaker;
        break;
    case EMemSpyDriverContainerTypeMsgQueue:
 	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeMsgQueue" ));
        type = EMsgQueue;
        break;
    case EMemSpyDriverContainerTypePropertyRef:
 	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypePropertyRef" ));
        type = EPropertyRef;
        break;
    case EMemSpyDriverContainerTypeCondVar:
 	    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType() - EMemSpyDriverContainerTypeCondVar" ));
        type = ECondVar;
        break;
    default:
        Kern::Printf("DMemSpyDriverLogChanContainerBase::ObjectTypeFromMemSpyContainerType - unsupported container type: %d", aType);
        break;
        }
    //
    return type;
    }




























    

void DMemSpyDriverLogChanContainerBase::ResetTempHandles()
    {
    iTempHandleCount = 0;
    }


void DMemSpyDriverLogChanContainerBase::AddTempHandle( TAny* aHandle )
    {
    __ASSERT_ALWAYS( iTempHandleCount >= 0, MemSpyDriverUtils::Fault( __LINE__) );
    if  ( iTempHandleCount < KMemSpyDriverMaxHandles )
        {
        iTempHandles[ iTempHandleCount++ ] = aHandle;
        }
    }


TAny* DMemSpyDriverLogChanContainerBase::TempHandleAt( TInt aIndex ) const
    {
    __ASSERT_ALWAYS( aIndex >= 0 && aIndex < KMemSpyDriverMaxHandles, MemSpyDriverUtils::Fault(__LINE__) );
    __ASSERT_ALWAYS( aIndex < iTempHandleCount, MemSpyDriverUtils::Fault(__LINE__) );
    return iTempHandles[ aIndex ];
    }


TInt DMemSpyDriverLogChanContainerBase::TempHandleCount() const
    {
    TRACE( Kern::Printf( "DMemSpyDriverLogChanContainerBase::TempHandleCount() - END - count is: %d", iTempHandleCount ));
    return iTempHandleCount;
    }


TInt DMemSpyDriverLogChanContainerBase::WriteToClient( TAny** aHandlePtr, TInt* aCountPtr, TInt aMaxCount )
    {
	TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::WriteToClient() - START - iTempHandleCount: %d", iTempHandleCount ));

    TInt r = KErrNone;

    // This variable holds the number of handles that we have already
	// written to the client-side.
	TInt currentWriteIndex = 0;

    // If the client passed a bad descriptor then we panic it. Otherwise, we always update the amount
    // of handles we have found (even if there was an error - i.e. we set the value to zero) or else
    // the client will attempt to index through its huge stack-based handle array.
	NKern::ThreadEnterCS();
    TInt tempHandleCount = TempHandleCount();
    TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::GetContainerHandles - trying to write %d handles to client...", tempHandleCount ));

    for( ; currentWriteIndex<tempHandleCount && r == KErrNone && currentWriteIndex < aMaxCount; )
        {
        TAny* handle = TempHandleAt( currentWriteIndex );
        r = Kern::ThreadRawWrite( &ClientThread(), aHandlePtr + currentWriteIndex, &handle, sizeof(TAny*) );
        if  (r == KErrNone)
            {
            ++currentWriteIndex;
            }
        }

	if  ( r == KErrBadDescriptor )
        {
        MemSpyDriverUtils::PanicThread( ClientThread(), EPanicBadDescriptor );
        }
    else
        {
        const TInt finalWrite = Kern::ThreadRawWrite( &ClientThread(), aCountPtr, &currentWriteIndex, sizeof(TInt) );
        if  ( r == KErrNone )
            {
            r = finalWrite;
            }
        }
	NKern::ThreadLeaveCS();

	TRACE( Kern::Printf("DMemSpyDriverLogChanContainerBase::GetContainerHandles() - END - r: %d", r));
	return r;
    }