memspy/Driver/Kernel/Source/SubChannels/MemSpyDriverLogChanProcessInspection.cpp
changeset 0 a03f92240627
equal deleted inserted replaced
-1:000000000000 0:a03f92240627
       
     1 /*
       
     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description:
       
    15 *
       
    16 */
       
    17 
       
    18 #include "MemSpyDriverLogChanProcessInspection.h"
       
    19 
       
    20 // System includes
       
    21 #include <u32hal.h>
       
    22 #include <e32rom.h>
       
    23 #include <memspy/driver/memspydriverobjectsshared.h>
       
    24 
       
    25 // Shared includes
       
    26 #include "MemSpyDriverOpCodes.h"
       
    27 #include "MemSpyDriverObjectsInternal.h"
       
    28 
       
    29 // User includes
       
    30 #include "MemSpyDriverUtils.h"
       
    31 #include "MemSpyDriverDevice.h"
       
    32 #include "MemSpyDriverInspectedProcess.h"
       
    33 #include "MemSpyDriverInspectedProcessManager.h"
       
    34 
       
    35 
       
    36 DMemSpyDriverLogChanProcessInspection::DMemSpyDriverLogChanProcessInspection( DMemSpyDriverDevice& aDevice, DThread& aThread )
       
    37 :   DMemSpyDriverLogChanBase( aDevice, aThread )
       
    38     {
       
    39     TRACE( Kern::Printf("DMemSpyDriverLogChanProcessInspection::DMemSpyDriverLogChanProcessInspection() - this: 0x%08x", this ));
       
    40     }
       
    41 
       
    42 
       
    43 DMemSpyDriverLogChanProcessInspection::~DMemSpyDriverLogChanProcessInspection()
       
    44 	{
       
    45 	TRACE( Kern::Printf("DMemSpyDriverLogChanProcessInspection::~DMemSpyDriverLogChanProcessInspection() - START - this: 0x%08x", this ));
       
    46 
       
    47 	TRACE( Kern::Printf("DMemSpyDriverLogChanProcessInspection::~DMemSpyDriverLogChanProcessInspection() - END - this: 0x%08x", this ));
       
    48 	}
       
    49 
       
    50 
       
    51 
       
    52 
       
    53 
       
    54 
       
    55 TInt DMemSpyDriverLogChanProcessInspection::Request( TInt aFunction, TAny* a1, TAny* a2 )
       
    56 	{
       
    57 	TInt r = DMemSpyDriverLogChanBase::Request( aFunction, a1, a2 );
       
    58     if  ( r == KErrNone )
       
    59         {
       
    60 	    switch( aFunction )
       
    61 		    {
       
    62         case EMemSpyDriverOpCodeProcessInspectOpen:
       
    63             r = ProcessInspectionOpen( (TUint) a1 );
       
    64             break;
       
    65         case EMemSpyDriverOpCodeProcessInspectClose:
       
    66             r = ProcessInspectionClose( (TUint) a1 );
       
    67             break;
       
    68         case EMemSpyDriverOpCodeProcessInspectRequestChanges:
       
    69             r = ProcessInspectionRequestChanges( (TRequestStatus*) a1, (TMemSpyDriverProcessInspectionInfo*) a2 );
       
    70             break;
       
    71         case EMemSpyDriverOpCodeProcessInspectRequestChangesCancel:
       
    72             r = ProcessInspectionRequestChangesCancel( (TUint) a1 );
       
    73             break;
       
    74         case EMemSpyDriverOpCodeProcessInspectAutoStartListReset:
       
    75             r = ProcessInspectionAutoStartItemsClear();
       
    76             break;
       
    77         case EMemSpyDriverOpCodeProcessInspectAutoStartListAdd:
       
    78             r = ProcessInspectionAutoStartItemsAdd( (TUint) a1 );
       
    79             break;
       
    80 
       
    81         default:
       
    82             r = KErrNotSupported;
       
    83 		    break;
       
    84 		    }
       
    85         }
       
    86     //
       
    87     return r;
       
    88 	}
       
    89 
       
    90 
       
    91 TBool DMemSpyDriverLogChanProcessInspection::IsHandler( TInt aFunction ) const
       
    92     {
       
    93     return ( aFunction > EMemSpyDriverOpCodeProcessInspectBase && aFunction < EMemSpyDriverOpCodeProcessInspectEnd );
       
    94     }
       
    95 
       
    96 
       
    97 
       
    98 
       
    99 
       
   100 
       
   101 
       
   102 
       
   103 
       
   104 
       
   105 
       
   106 
       
   107 
       
   108 
       
   109 
       
   110 
       
   111 
       
   112 
       
   113 
       
   114 
       
   115 
       
   116 
       
   117 
       
   118 
       
   119 
       
   120 
       
   121 TInt DMemSpyDriverLogChanProcessInspection::ProcessInspectionOpen( TUint aPid )
       
   122     {
       
   123 	TRACE( Kern::Printf("DMemSpyDriverLogChanProcessInspection::ProcessInspectionOpen() - START"));
       
   124     NKern::ThreadEnterCS();
       
   125     
       
   126     TInt error = OpenTempObject( aPid, EProcess );
       
   127     if  ( error == KErrNone )
       
   128     	{
       
   129         DMemSpyInspectedProcessManager& pidManager = MemSpyDevice().ProcessInspectionManager();
       
   130         error = pidManager.ProcessOpen( (DProcess*) TempObject() );
       
   131 	    CloseTempObject();
       
   132     	}
       
   133     //
       
   134     NKern::ThreadLeaveCS();
       
   135 	TRACE( Kern::Printf("DMemSpyDriverLogChanProcessInspection::ProcessInspectionOpen() - END - error: %d", error ));
       
   136     return error;
       
   137     }
       
   138 
       
   139 
       
   140 TInt DMemSpyDriverLogChanProcessInspection::ProcessInspectionClose( TUint aPid )
       
   141     {
       
   142 	TRACE( Kern::Printf("DMemSpyDriverLogChanProcessInspection::ProcessInspectionClose() - START"));
       
   143     NKern::ThreadEnterCS();
       
   144 
       
   145     TInt error = OpenTempObject( aPid, EProcess );
       
   146     if  ( error == KErrNone )
       
   147     	{
       
   148         DMemSpyInspectedProcessManager& pidManager = MemSpyDevice().ProcessInspectionManager();
       
   149         error = pidManager.ProcessClose( (DProcess*) TempObject() );
       
   150 	    CloseTempObject();
       
   151     	}
       
   152     
       
   153     NKern::ThreadLeaveCS();
       
   154 
       
   155 	TRACE( Kern::Printf("DMemSpyDriverLogChanProcessInspection::ProcessInspectionClose() - END - error: %d", error ));
       
   156     return error;
       
   157     }
       
   158 
       
   159 
       
   160 TInt DMemSpyDriverLogChanProcessInspection::ProcessInspectionRequestChanges( TRequestStatus* aStatus, TMemSpyDriverProcessInspectionInfo* aInfo )
       
   161     {
       
   162 	TRACE( Kern::Printf("DMemSpyDriverLogChanProcessInspection::ProcessInspectionRequestChanges() - START"));
       
   163     NKern::ThreadEnterCS();
       
   164 
       
   165     // Read client info
       
   166     TMemSpyDriverProcessInspectionInfo info;
       
   167 	TInt error = Kern::ThreadRawRead( &ClientThread(), aInfo, &info, sizeof(TMemSpyDriverProcessInspectionInfo) );
       
   168     //
       
   169     if  ( error == KErrNone )
       
   170         {
       
   171         DMemSpyInspectedProcessManager& pidManager = MemSpyDevice().ProcessInspectionManager();
       
   172         DMemSpyInspectedProcess* pid = pidManager.InspectedProcessByProcessId( info.iProcessId );
       
   173         //
       
   174         if ( pid != NULL )
       
   175             {
       
   176             error = pid->NotifyOnChange( &ClientThread(), aStatus, aInfo );
       
   177             }
       
   178         else
       
   179             {
       
   180             error = KErrNotFound;
       
   181             }
       
   182         }
       
   183 
       
   184     // NB: Let client take care of completing request in error situations
       
   185     NKern::ThreadLeaveCS();
       
   186 	TRACE( Kern::Printf("DMemSpyDriverLogChanProcessInspection::ProcessInspectionRequestChanges() - END - error: %d", error ));
       
   187     return error;
       
   188     }
       
   189 
       
   190 
       
   191 TInt DMemSpyDriverLogChanProcessInspection::ProcessInspectionRequestChangesCancel( TUint aPid )
       
   192     {
       
   193 	TRACE( Kern::Printf("DMemSpyDriverLogChanProcessInspection::ProcessInspectionRequestChangesCancel() - START"));
       
   194     NKern::ThreadEnterCS();
       
   195 
       
   196     TInt error = KErrNotFound;
       
   197 
       
   198     DMemSpyInspectedProcessManager& pidManager = MemSpyDevice().ProcessInspectionManager();
       
   199     DMemSpyInspectedProcess* pid = pidManager.InspectedProcessByProcessId( aPid );
       
   200     //
       
   201     if ( pid != NULL )
       
   202         {
       
   203         error = pid->NotifyOnChangeCancel();
       
   204         }
       
   205 
       
   206     NKern::ThreadLeaveCS();
       
   207 
       
   208 	TRACE( Kern::Printf("DMemSpyDriverLogChanProcessInspection::ProcessInspectionRequestChangesCancel() - END - error: %d", error ));
       
   209     return error;
       
   210     }
       
   211 
       
   212 
       
   213 TInt DMemSpyDriverLogChanProcessInspection::ProcessInspectionAutoStartItemsClear()
       
   214     {
       
   215 	TRACE( Kern::Printf("DMemSpyDriverLogChanProcessInspection::ProcessInspectionAutoStartItemsClear() - START"));
       
   216 
       
   217     NKern::ThreadEnterCS();
       
   218 
       
   219     DMemSpyInspectedProcessManager& pidManager = MemSpyDevice().ProcessInspectionManager();
       
   220     pidManager.AutoStartListReset();
       
   221 
       
   222     NKern::ThreadLeaveCS();
       
   223 
       
   224 	TRACE( Kern::Printf("DMemSpyDriverLogChanProcessInspection::ProcessInspectionAutoStartItemsClear() - END" ));
       
   225     return KErrNone;
       
   226     }
       
   227 
       
   228 
       
   229 TInt DMemSpyDriverLogChanProcessInspection::ProcessInspectionAutoStartItemsAdd( TUint aSID )
       
   230     {
       
   231 	TRACE( Kern::Printf("DMemSpyDriverLogChanProcessInspection::ProcessInspectionAutoStartItemsAdd() - START - aSID: 0x%08x", aSID ));
       
   232 
       
   233     NKern::ThreadEnterCS();
       
   234     DMemSpyInspectedProcessManager& pidManager = MemSpyDevice().ProcessInspectionManager();
       
   235     const TInt error = pidManager.AutoStartListAdd( aSID );
       
   236     NKern::ThreadLeaveCS();
       
   237 
       
   238 	TRACE( Kern::Printf("DMemSpyDriverLogChanProcessInspection::ProcessInspectionAutoStartItemsAdd() - END - error: %d", error ));
       
   239     return error;
       
   240     }
       
   241 
       
   242 
       
   243 
       
   244 
       
   245 
       
   246 
       
   247 
       
   248 
       
   249 
       
   250 
       
   251 
       
   252 
       
   253 
       
   254 
       
   255 
       
   256