perfsrv/memspy/Driver/Kernel/Source/MemSpyDriverLogicalChannel.cpp
author hgs
Mon, 20 Sep 2010 12:20:18 +0300
changeset 52 c2f44e33b468
parent 51 98307c651589
permissions -rw-r--r--
201037
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
51
hgs
parents:
diff changeset
     1
/*
hgs
parents:
diff changeset
     2
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 
hgs
parents:
diff changeset
     3
* All rights reserved.
hgs
parents:
diff changeset
     4
* This component and the accompanying materials are made available
hgs
parents:
diff changeset
     5
* under the terms of "Eclipse Public License v1.0"
hgs
parents:
diff changeset
     6
* which accompanies this distribution, and is available
hgs
parents:
diff changeset
     7
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
hgs
parents:
diff changeset
     8
*
hgs
parents:
diff changeset
     9
* Initial Contributors:
hgs
parents:
diff changeset
    10
* Nokia Corporation - initial contribution.
hgs
parents:
diff changeset
    11
*
hgs
parents:
diff changeset
    12
* Contributors:
hgs
parents:
diff changeset
    13
*
hgs
parents:
diff changeset
    14
* Description:
hgs
parents:
diff changeset
    15
*
hgs
parents:
diff changeset
    16
*/
hgs
parents:
diff changeset
    17
hgs
parents:
diff changeset
    18
#include "MemSpyDriverLogicalChannel.h"
hgs
parents:
diff changeset
    19
hgs
parents:
diff changeset
    20
// System includes
hgs
parents:
diff changeset
    21
#include <u32hal.h>
hgs
parents:
diff changeset
    22
#include <e32rom.h>
hgs
parents:
diff changeset
    23
hgs
parents:
diff changeset
    24
// User includes
hgs
parents:
diff changeset
    25
#include "MemSpyDriverUtils.h"
hgs
parents:
diff changeset
    26
#include "MemSpyDriverDevice.h"
hgs
parents:
diff changeset
    27
#include <memspy/driver/memspydriverconstants.h>
hgs
parents:
diff changeset
    28
#include "MemSpyDriverLogChanChunks.h"
hgs
parents:
diff changeset
    29
#include "MemSpyDriverLogChanClientServer.h"
hgs
parents:
diff changeset
    30
#include "MemSpyDriverLogChanCodeSegs.h"
hgs
parents:
diff changeset
    31
#include "MemSpyDriverLogChanContainers.h"
52
hgs
parents: 51
diff changeset
    32
#include "MemSpyDriverLogChanHeapDataUser.h"
hgs
parents: 51
diff changeset
    33
#include "MemSpyDriverLogChanHeapDataKernel.h"
hgs
parents: 51
diff changeset
    34
#include "MemSpyDriverLogChanHeapWalkUser.h"
51
hgs
parents:
diff changeset
    35
#include "MemSpyDriverLogChanMisc.h"
hgs
parents:
diff changeset
    36
#include "MemSpyDriverLogChanProcessInspection.h"
hgs
parents:
diff changeset
    37
#include "MemSpyDriverLogChanStack.h"
hgs
parents:
diff changeset
    38
#include "MemSpyDriverLogChanRawMemory.h"
hgs
parents:
diff changeset
    39
#include "MemSpyDriverLogChanUserEventMonitor.h"
hgs
parents:
diff changeset
    40
#include "MemSpyDriverLogChanThreadAndProcess.h"
hgs
parents:
diff changeset
    41
hgs
parents:
diff changeset
    42
hgs
parents:
diff changeset
    43
DMemSpyDriverLogicalChannel::DMemSpyDriverLogicalChannel()
hgs
parents:
diff changeset
    44
    {
hgs
parents:
diff changeset
    45
    }
hgs
parents:
diff changeset
    46
hgs
parents:
diff changeset
    47
hgs
parents:
diff changeset
    48
DMemSpyDriverLogicalChannel::~DMemSpyDriverLogicalChannel()
hgs
parents:
diff changeset
    49
	{
hgs
parents:
diff changeset
    50
	TRACE( Kern::Printf("DMemSpyDriverLogicalChannel::~DMemSpyDriverLogicalChannel() - START"));
hgs
parents:
diff changeset
    51
hgs
parents:
diff changeset
    52
    NKern::ThreadEnterCS();
hgs
parents:
diff changeset
    53
    SubChannelsDestroy();
hgs
parents:
diff changeset
    54
hgs
parents:
diff changeset
    55
    TRACE( Kern::Printf("DMemSpyDriverLogicalChannel::~DMemSpyDriverLogicalChannel() - closing client thread..."));
hgs
parents:
diff changeset
    56
    Kern::SafeClose( (DObject*&) iClientThread, NULL );
hgs
parents:
diff changeset
    57
    NKern::ThreadLeaveCS();
hgs
parents:
diff changeset
    58
hgs
parents:
diff changeset
    59
    TRACE( Kern::Printf("DMemSpyDriverLogicalChannel::~DMemSpyDriverLogicalChannel() - calling device to cleanup..."));
hgs
parents:
diff changeset
    60
    MemSpyDevice().Cleanup();
hgs
parents:
diff changeset
    61
hgs
parents:
diff changeset
    62
    TRACE( Kern::Printf("DMemSpyDriverLogicalChannel::~DMemSpyDriverLogicalChannel() - END"));
hgs
parents:
diff changeset
    63
	}
hgs
parents:
diff changeset
    64
hgs
parents:
diff changeset
    65
hgs
parents:
diff changeset
    66
TInt DMemSpyDriverLogicalChannel::DoCreate( TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& aVer )
hgs
parents:
diff changeset
    67
	{
hgs
parents:
diff changeset
    68
	TRACE( Kern::Printf("DMemSpyDriverLogicalChannel::DoCreate() - START - heldFM: %d, device: 0x%08x", Kern::CurrentThread().iNThread.iHeldFastMutex != NULL, &MemSpyDevice() ) );
hgs
parents:
diff changeset
    69
hgs
parents:
diff changeset
    70
    TInt error = KErrNone;
hgs
parents:
diff changeset
    71
    //
hgs
parents:
diff changeset
    72
    if  ( !Kern::QueryVersionSupported( KMemSpyDriverVersion(), aVer ) )
hgs
parents:
diff changeset
    73
        {
hgs
parents:
diff changeset
    74
        error = KErrNotSupported;
hgs
parents:
diff changeset
    75
        }
hgs
parents:
diff changeset
    76
    else
hgs
parents:
diff changeset
    77
        {
hgs
parents:
diff changeset
    78
        // Try to get the memory model type
hgs
parents:
diff changeset
    79
        
hgs
parents:
diff changeset
    80
    	TRACE( Kern::Printf("DMemSpyDriverLogicalChannel::DoCreate - opening client thread..."));
hgs
parents:
diff changeset
    81
hgs
parents:
diff changeset
    82
        iClientThread = &Kern::CurrentThread();
hgs
parents:
diff changeset
    83
	    error = iClientThread->Open();
hgs
parents:
diff changeset
    84
        TRACE( Kern::Printf("DMemSpyDriverLogicalChannel::DoCreate - client thread open error: %d", error ));
hgs
parents:
diff changeset
    85
hgs
parents:
diff changeset
    86
        if  ( error == KErrNone )
hgs
parents:
diff changeset
    87
            {
hgs
parents:
diff changeset
    88
            TRACE( Kern::Printf("DMemSpyDriverLogicalChannel::DoCreate - creating sub channels error: %d", error ));
hgs
parents:
diff changeset
    89
            error = SubChannelsRegister();
hgs
parents:
diff changeset
    90
            }
hgs
parents:
diff changeset
    91
        }
hgs
parents:
diff changeset
    92
    //
hgs
parents:
diff changeset
    93
	TRACE( Kern::Printf("DMemSpyDriverLogicalChannel::DoCreate() - END - heldFM: %d", Kern::CurrentThread().iNThread.iHeldFastMutex != NULL ) );
hgs
parents:
diff changeset
    94
    return error;
hgs
parents:
diff changeset
    95
	}
hgs
parents:
diff changeset
    96
hgs
parents:
diff changeset
    97
hgs
parents:
diff changeset
    98
hgs
parents:
diff changeset
    99
hgs
parents:
diff changeset
   100
hgs
parents:
diff changeset
   101
hgs
parents:
diff changeset
   102
hgs
parents:
diff changeset
   103
hgs
parents:
diff changeset
   104
hgs
parents:
diff changeset
   105
hgs
parents:
diff changeset
   106
hgs
parents:
diff changeset
   107
hgs
parents:
diff changeset
   108
TInt DMemSpyDriverLogicalChannel::Request( TInt aFunction, TAny* a1, TAny* a2 )
hgs
parents:
diff changeset
   109
	{
hgs
parents:
diff changeset
   110
	TRACE( Kern::Printf(" " ) );
hgs
parents:
diff changeset
   111
	TRACE( Kern::Printf(" " ) );
hgs
parents:
diff changeset
   112
	TRACE( Kern::Printf("--------------------------------------------------------------------------------------------------------------------- " ) );
hgs
parents:
diff changeset
   113
	TRACE_OP( Kern::Printf("DMemSpyDriverLogicalChannel::Request() - START - fn: %3d, a1: 0x%08x, a2: 0x%08x, heldFM: %d", aFunction, a1, a2, iClientThread->iNThread.iHeldFastMutex != NULL ) );
hgs
parents:
diff changeset
   114
	TRACE( Kern::Printf("--------------------------------------------------------------------------------------------------------------------- " ) );
hgs
parents:
diff changeset
   115
	//
hgs
parents:
diff changeset
   116
    TInt r = KErrNotSupported;
hgs
parents:
diff changeset
   117
    //
hgs
parents:
diff changeset
   118
    DMemSpyDriverLogChanBase* handler = SubChannelForFunction( aFunction );
hgs
parents:
diff changeset
   119
    if  ( handler )
hgs
parents:
diff changeset
   120
        {
hgs
parents:
diff changeset
   121
        r = handler->Request( aFunction, a1, a2 );
hgs
parents:
diff changeset
   122
        }
hgs
parents:
diff changeset
   123
    //
hgs
parents:
diff changeset
   124
#ifdef _DEBUG
hgs
parents:
diff changeset
   125
    if  ( r < 0 && r != KErrEof )
hgs
parents:
diff changeset
   126
        {
hgs
parents:
diff changeset
   127
	    Kern::Printf( "DMemSpyDriverLogicalChannel::Request() - END - fn: %3d, a1: 0x%08x, a2: 0x%08x, heldFM: %d, r: %d", aFunction, a1, a2, iClientThread->iNThread.iHeldFastMutex != NULL, r );
hgs
parents:
diff changeset
   128
        }
hgs
parents:
diff changeset
   129
#endif
hgs
parents:
diff changeset
   130
	TRACE( Kern::Printf(" " ) );
hgs
parents:
diff changeset
   131
	TRACE( Kern::Printf(" " ) );
hgs
parents:
diff changeset
   132
    //
hgs
parents:
diff changeset
   133
    return r;
hgs
parents:
diff changeset
   134
	}
hgs
parents:
diff changeset
   135
hgs
parents:
diff changeset
   136
hgs
parents:
diff changeset
   137
hgs
parents:
diff changeset
   138
hgs
parents:
diff changeset
   139
hgs
parents:
diff changeset
   140
hgs
parents:
diff changeset
   141
hgs
parents:
diff changeset
   142
hgs
parents:
diff changeset
   143
hgs
parents:
diff changeset
   144
hgs
parents:
diff changeset
   145
hgs
parents:
diff changeset
   146
hgs
parents:
diff changeset
   147
hgs
parents:
diff changeset
   148
TInt DMemSpyDriverLogicalChannel::SubChannelsRegister()
hgs
parents:
diff changeset
   149
    {
hgs
parents:
diff changeset
   150
    TInt r = KErrNone;
hgs
parents:
diff changeset
   151
    DMemSpyDriverDevice& device = MemSpyDevice();
hgs
parents:
diff changeset
   152
    DMemSpyDriverLogChanBase* subChan = NULL;
hgs
parents:
diff changeset
   153
    //
hgs
parents:
diff changeset
   154
    subChan = new DMemSpyDriverLogChanChunks( device, *iClientThread );
hgs
parents:
diff changeset
   155
    r = SubChannelConstructAndSave( subChan );
hgs
parents:
diff changeset
   156
    if ( r != KErrNone )
hgs
parents:
diff changeset
   157
        {
hgs
parents:
diff changeset
   158
        return r;
hgs
parents:
diff changeset
   159
        }
hgs
parents:
diff changeset
   160
    //
hgs
parents:
diff changeset
   161
    subChan = new DMemSpyDriverLogChanClientServer( device, *iClientThread );
hgs
parents:
diff changeset
   162
    r = SubChannelConstructAndSave( subChan );
hgs
parents:
diff changeset
   163
    if ( r != KErrNone )
hgs
parents:
diff changeset
   164
        {
hgs
parents:
diff changeset
   165
        return r;
hgs
parents:
diff changeset
   166
        }
hgs
parents:
diff changeset
   167
    //
hgs
parents:
diff changeset
   168
    subChan = new DMemSpyDriverLogChanCodeSegs( device, *iClientThread );
hgs
parents:
diff changeset
   169
    r = SubChannelConstructAndSave( subChan );
hgs
parents:
diff changeset
   170
    if ( r != KErrNone )
hgs
parents:
diff changeset
   171
        {
hgs
parents:
diff changeset
   172
        return r;
hgs
parents:
diff changeset
   173
        }
hgs
parents:
diff changeset
   174
    //
hgs
parents:
diff changeset
   175
    subChan = new DMemSpyDriverLogChanContainers( device, *iClientThread );
hgs
parents:
diff changeset
   176
    r = SubChannelConstructAndSave( subChan );
hgs
parents:
diff changeset
   177
    if ( r != KErrNone )
hgs
parents:
diff changeset
   178
        {
hgs
parents:
diff changeset
   179
        return r;
hgs
parents:
diff changeset
   180
        }
hgs
parents:
diff changeset
   181
    //
52
hgs
parents: 51
diff changeset
   182
    subChan = new DMemSpyDriverLogChanHeapDataUser( device, *iClientThread );
51
hgs
parents:
diff changeset
   183
    r = SubChannelConstructAndSave( subChan );
hgs
parents:
diff changeset
   184
    if ( r != KErrNone )
hgs
parents:
diff changeset
   185
        {
hgs
parents:
diff changeset
   186
        return r;
hgs
parents:
diff changeset
   187
        }
hgs
parents:
diff changeset
   188
    //
52
hgs
parents: 51
diff changeset
   189
    subChan = new DMemSpyDriverLogChanHeapDataKernel( device, *iClientThread );
51
hgs
parents:
diff changeset
   190
    r = SubChannelConstructAndSave( subChan );
hgs
parents:
diff changeset
   191
    if ( r != KErrNone )
hgs
parents:
diff changeset
   192
        {
hgs
parents:
diff changeset
   193
        return r;
hgs
parents:
diff changeset
   194
        }
hgs
parents:
diff changeset
   195
    //
52
hgs
parents: 51
diff changeset
   196
    subChan = new DMemSpyDriverLogChanHeapWalkUser( device, *iClientThread );
51
hgs
parents:
diff changeset
   197
    r = SubChannelConstructAndSave( subChan );
hgs
parents:
diff changeset
   198
    if ( r != KErrNone )
hgs
parents:
diff changeset
   199
        {
hgs
parents:
diff changeset
   200
        return r;
hgs
parents:
diff changeset
   201
        }
hgs
parents:
diff changeset
   202
    //
hgs
parents:
diff changeset
   203
    subChan = new DMemSpyDriverLogChanMisc( device, *iClientThread );
hgs
parents:
diff changeset
   204
    r = SubChannelConstructAndSave( subChan );
hgs
parents:
diff changeset
   205
    if ( r != KErrNone )
hgs
parents:
diff changeset
   206
        {
hgs
parents:
diff changeset
   207
        return r;
hgs
parents:
diff changeset
   208
        }
hgs
parents:
diff changeset
   209
    //
hgs
parents:
diff changeset
   210
    subChan = new DMemSpyDriverLogChanProcessInspection( device, *iClientThread );
hgs
parents:
diff changeset
   211
    r = SubChannelConstructAndSave( subChan );
hgs
parents:
diff changeset
   212
    if ( r != KErrNone )
hgs
parents:
diff changeset
   213
        {
hgs
parents:
diff changeset
   214
        return r;
hgs
parents:
diff changeset
   215
        }
hgs
parents:
diff changeset
   216
    //
hgs
parents:
diff changeset
   217
    subChan = new DMemSpyDriverLogChanRawMemory( device, *iClientThread );
hgs
parents:
diff changeset
   218
    r = SubChannelConstructAndSave( subChan );
hgs
parents:
diff changeset
   219
    if ( r != KErrNone )
hgs
parents:
diff changeset
   220
        {
hgs
parents:
diff changeset
   221
        return r;
hgs
parents:
diff changeset
   222
        }
hgs
parents:
diff changeset
   223
    //
hgs
parents:
diff changeset
   224
    subChan = new DMemSpyDriverLogChanStack( device, *iClientThread );
hgs
parents:
diff changeset
   225
    r = SubChannelConstructAndSave( subChan );
hgs
parents:
diff changeset
   226
    if ( r != KErrNone )
hgs
parents:
diff changeset
   227
        {
hgs
parents:
diff changeset
   228
        return r;
hgs
parents:
diff changeset
   229
        }
hgs
parents:
diff changeset
   230
    //
hgs
parents:
diff changeset
   231
    subChan = new DMemSpyDriverLogChanThreadAndProcess( device, *iClientThread );
hgs
parents:
diff changeset
   232
    r = SubChannelConstructAndSave( subChan );
hgs
parents:
diff changeset
   233
    if ( r != KErrNone )
hgs
parents:
diff changeset
   234
        {
hgs
parents:
diff changeset
   235
        return r;
hgs
parents:
diff changeset
   236
        }
hgs
parents:
diff changeset
   237
    //
hgs
parents:
diff changeset
   238
    subChan = new DMemSpyDriverLogChanUserEventMonitor( device, *iClientThread );
hgs
parents:
diff changeset
   239
    r = SubChannelConstructAndSave( subChan );
hgs
parents:
diff changeset
   240
    if ( r != KErrNone )
hgs
parents:
diff changeset
   241
        {
hgs
parents:
diff changeset
   242
        return r;
hgs
parents:
diff changeset
   243
        }
hgs
parents:
diff changeset
   244
    //
hgs
parents:
diff changeset
   245
    return r;
hgs
parents:
diff changeset
   246
    }
hgs
parents:
diff changeset
   247
hgs
parents:
diff changeset
   248
hgs
parents:
diff changeset
   249
TInt DMemSpyDriverLogicalChannel::SubChannelConstructAndSave( DMemSpyDriverLogChanBase*& aSubChannel )
hgs
parents:
diff changeset
   250
    {
hgs
parents:
diff changeset
   251
    TInt r = KErrNoMemory;
hgs
parents:
diff changeset
   252
    //
hgs
parents:
diff changeset
   253
    if ( aSubChannel )
hgs
parents:
diff changeset
   254
        {
hgs
parents:
diff changeset
   255
        NKern::ThreadEnterCS();
hgs
parents:
diff changeset
   256
        r = aSubChannel->Construct();
hgs
parents:
diff changeset
   257
        //
hgs
parents:
diff changeset
   258
        if  ( r == KErrNone )
hgs
parents:
diff changeset
   259
            {
hgs
parents:
diff changeset
   260
            r = iSubChannels.Append( aSubChannel );
hgs
parents:
diff changeset
   261
            if  ( r != KErrNone )
hgs
parents:
diff changeset
   262
                {
hgs
parents:
diff changeset
   263
                delete aSubChannel;
hgs
parents:
diff changeset
   264
                }
hgs
parents:
diff changeset
   265
            }
hgs
parents:
diff changeset
   266
        else
hgs
parents:
diff changeset
   267
            {
hgs
parents:
diff changeset
   268
            delete aSubChannel;
hgs
parents:
diff changeset
   269
            }
hgs
parents:
diff changeset
   270
        //
hgs
parents:
diff changeset
   271
        NKern::ThreadLeaveCS();
hgs
parents:
diff changeset
   272
        }
hgs
parents:
diff changeset
   273
    //
hgs
parents:
diff changeset
   274
    aSubChannel = NULL;
hgs
parents:
diff changeset
   275
    return r;
hgs
parents:
diff changeset
   276
    }
hgs
parents:
diff changeset
   277
hgs
parents:
diff changeset
   278
hgs
parents:
diff changeset
   279
void DMemSpyDriverLogicalChannel::SubChannelsDestroy()
hgs
parents:
diff changeset
   280
    {
hgs
parents:
diff changeset
   281
    const TInt count = iSubChannels.Count();
hgs
parents:
diff changeset
   282
	TRACE( Kern::Printf("DMemSpyDriverLogicalChannel::SubChannelsDestroy() - START - count: %d", count ) );
hgs
parents:
diff changeset
   283
    //
hgs
parents:
diff changeset
   284
    NKern::ThreadEnterCS();
hgs
parents:
diff changeset
   285
    for( TInt i=0; i<count; i++ )
hgs
parents:
diff changeset
   286
        {
hgs
parents:
diff changeset
   287
        DMemSpyDriverLogChanBase* subChan = iSubChannels[ i ];
hgs
parents:
diff changeset
   288
	    TRACE( Kern::Printf("DMemSpyDriverLogicalChannel::SubChannelsDestroy() - deleting subChannel: 0x%08x", subChan ) );
hgs
parents:
diff changeset
   289
        delete subChan;
hgs
parents:
diff changeset
   290
        }
hgs
parents:
diff changeset
   291
    //
hgs
parents:
diff changeset
   292
    iSubChannels.Reset();
hgs
parents:
diff changeset
   293
    NKern::ThreadLeaveCS();
hgs
parents:
diff changeset
   294
    //
hgs
parents:
diff changeset
   295
	TRACE( Kern::Printf("DMemSpyDriverLogicalChannel::SubChannelsDestroy() - END" ) );
hgs
parents:
diff changeset
   296
    }
hgs
parents:
diff changeset
   297
hgs
parents:
diff changeset
   298
hgs
parents:
diff changeset
   299
DMemSpyDriverLogChanBase* DMemSpyDriverLogicalChannel::SubChannelForFunction( TInt aFunction )
hgs
parents:
diff changeset
   300
    {
hgs
parents:
diff changeset
   301
	TRACE( Kern::Printf("DMemSpyDriverLogicalChannel::SubChannelForFunction() - START - aFunction: %d", aFunction ) );
hgs
parents:
diff changeset
   302
    //
hgs
parents:
diff changeset
   303
    DMemSpyDriverLogChanBase* ret = NULL;
hgs
parents:
diff changeset
   304
    const TInt count = iSubChannels.Count();
hgs
parents:
diff changeset
   305
    for( TInt i=0; i<count; i++ )
hgs
parents:
diff changeset
   306
        {
hgs
parents:
diff changeset
   307
        DMemSpyDriverLogChanBase* subChan = iSubChannels[ i ];
hgs
parents:
diff changeset
   308
        if  ( subChan->IsHandler( aFunction ) )
hgs
parents:
diff changeset
   309
            {
hgs
parents:
diff changeset
   310
            ret = subChan;
hgs
parents:
diff changeset
   311
            break;
hgs
parents:
diff changeset
   312
            }
hgs
parents:
diff changeset
   313
        }
hgs
parents:
diff changeset
   314
    //
hgs
parents:
diff changeset
   315
	TRACE( Kern::Printf("DMemSpyDriverLogicalChannel::SubChannelForFunction() - END - aFunction: %d, subChannel: 0x%08x", aFunction, ret ) );
hgs
parents:
diff changeset
   316
    return ret;
hgs
parents:
diff changeset
   317
    }
hgs
parents:
diff changeset
   318
hgs
parents:
diff changeset
   319
hgs
parents:
diff changeset
   320
DMemSpyDriverDevice& DMemSpyDriverLogicalChannel::MemSpyDevice()
hgs
parents:
diff changeset
   321
    {
hgs
parents:
diff changeset
   322
    DMemSpyDriverDevice& device = *((DMemSpyDriverDevice*) iDevice);
hgs
parents:
diff changeset
   323
    return device;
hgs
parents:
diff changeset
   324
    }
hgs
parents:
diff changeset
   325