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 <memspy/engine/memspyengineimp.h>

    19 

    20 // System includes

    21 #include <e32svr.h>

    22 

    23 // Driver includes

    24 #include <memspy/driver/memspydriverclient.h>

    25 

    26 // User includes

    27 #include <memspy/engine/memspyengineobjectthread.h>

    28 #include <memspy/engine/memspyengineobjectprocess.h>

    29 #include <memspy/engine/memspyengineobjectcontainer.h>

    30 #include <memspy/engine/memspyengineundertaker.h>

    31 #include "MemSpyEngineChunkWatcher.h"

    32 #include <memspy/engine/memspyengineobserver.h>

    33 #include "MemSpyEngineServer.h"

    34 #include <memspy/engine/memspyengineutils.h>

    35 #include "MemSpyEngineOutputSinkDebug.h"

    36 #include "MemSpyEngineOutputSinkFile.h"

    37 #include <memspy/engine/memspyenginehelperchunk.h>

    38 #include <memspy/engine/memspyenginehelpercodesegment.h>

    39 #include <memspy/engine/memspyenginehelperheap.h>

    40 #include <memspy/engine/memspyenginehelperstack.h>

    41 #include <memspy/engine/memspyenginehelperthread.h>

    42 #include <memspy/engine/memspyenginehelperserver.h>

    43 #include <memspy/engine/memspyenginehelperprocess.h>

    44 #include <memspy/engine/memspyenginehelperactiveobject.h>

    45 #include <memspy/engine/memspyenginehelperkernelcontainers.h>

    46 #include <memspy/engine/memspyenginehelperfilesystem.h>

    47 #include <memspy/engine/memspyenginehelperecom.h>

    48 #include <memspy/engine/memspyenginehelpersysmemtracker.h>

    49 #include <memspy/engine/memspyenginehelperfbserv.h>

    50 #include <memspy/engine/memspyenginehelperrom.h>

    51 #include <memspy/engine/memspyenginehelperram.h>

    52 #include <memspy/engine/memspyenginehelperwindowserver.h>

    53 #include <memspy/engine/memspyenginehelpercondvar.h>

    54 

    55 

    56 CMemSpyEngineImp::CMemSpyEngineImp( RFs& aFsSession, CMemSpyEngine& aEngine )

    57 :   iFsSession( aFsSession ), iEngine( aEngine )

    58     {

    59     }

    60 

    61 

    62 CMemSpyEngineImp::~CMemSpyEngineImp()

    63     {

    64 #ifdef _DEBUG

    65     RDebug::Printf( "CMemSpyEngineImp::~CMemSpyEngineImp() - START" );

    66 #endif

    67 

    68     if  ( iMidwife )

    69         {

    70         iMidwife->RemoveObserver( *this );

    71         }

    72 

    73 #ifdef _DEBUG

    74     RDebug::Printf( "CMemSpyEngineImp::~CMemSpyEngineImp() - deleting helpers..." );

    75 #endif

    76     delete iHelperSysMemTracker;

    77     delete iServer;

    78     delete iHelperKernelContainers;

    79     delete iHelperFbServ;

    80     delete iHelperHeap;

    81     delete iHelperStack;

    82     delete iHelperCodeSegment;

    83     delete iHelperChunk;

    84     delete iHelperThread;

    85     delete iHelperProcess;

    86     delete iHelperServer;

    87     delete iHelperActiveObject;

    88     delete iHelperFileSystem;

    89     delete iHelperECom;

    90     delete iHelperROM;

    91     delete iHelperRAM;

    92     delete iHelperWindowServer;

    93     delete iHelperCondVar;

    94     

    95     iHelperWindowServerLoader.Close();

    96 

    97 #ifdef _DEBUG

    98     RDebug::Printf( "CMemSpyEngineImp::~CMemSpyEngineImp() - deleting utilities..." );

    99 #endif

   100     delete iChunkWatcher;

   101     delete iUndertaker;

   102     delete iMidwife;

   103 

   104 #ifdef _DEBUG

   105     RDebug::Printf( "CMemSpyEngineImp::~CMemSpyEngineImp() - destroying containers..." );

   106 #endif

   107     iContainers.ResetAndDestroy();

   108     iContainers.Close();

   109 

   110 #ifdef _DEBUG

   111     RDebug::Printf( "CMemSpyEngineImp::~CMemSpyEngineImp() - destroying driver..." );

   112 #endif

   113     if  ( iMemSpyDriver )

   114         {

   115         iMemSpyDriver->Close();

   116         delete iMemSpyDriver;

   117         }

   118 

   119 #ifdef _DEBUG

   120     RDebug::Printf( "CMemSpyEngineImp::~CMemSpyEngineImp() - destroying sink..." );

   121 #endif

   122     delete iSink;

   123 

   124 #ifdef _DEBUG

   125     RDebug::Printf( "CMemSpyEngineImp::~CMemSpyEngineImp() - END" );

   126 #endif

   127     }

   128 

   129 

   130 void CMemSpyEngineImp::ConstructL()

   131     {

   132 #ifdef _DEBUG

   133     RDebug::Printf( "CMemSpyEngineImp::ConstructL() - START" );

   134 #endif

   135     //

   136     iFsSession.SetSessionPath( _L("\\") );

   137     

   138     // Starting the server before the driver connection is made

   139     // ensures that only one instance of MemSpy can run (either the S60

   140     // UI or the console UI ).

   141     iServer = CMemSpyEngineServer::NewL( iEngine );

   142     //

   143     iMemSpyDriver = new(ELeave) RMemSpyDriverClient();

   144     const TInt error = Driver().Open();

   145     User::LeaveIfError( error );

   146     //

   147     InstallSinkL( ESinkTypeDebug );

   148     //

   149     iUndertaker = CMemSpyEngineUndertaker::NewL( Driver() );

   150     iUndertaker->AddObserverL( *this );

   151     //

   152     iMidwife = CMemSpyEngineMidwife::NewL( Driver() );

   153     //

   154     iChunkWatcher = CMemSpyEngineChunkWatcher::NewL( Driver() );

   155     //

   156     CMemSpyEngineObjectContainer* container = CMemSpyEngineObjectContainer::NewL( iEngine );

   157     CleanupStack::PushL( container );

   158     iContainers.InsertL( container, 0 );

   159     CleanupStack::Pop( container );

   160     //

   161     ConstructHelpersL();

   162     //

   163     iHelperSysMemTracker = CMemSpyEngineHelperSysMemTracker::NewL( iEngine );

   164     iMidwife->AddObserverL( *this );

   165 

   166 #ifdef _DEBUG

   167     RDebug::Printf( "CMemSpyEngineImp::ConstructL() - END" );

   168 #endif

   169     }

   170 

   171 

   172 void CMemSpyEngineImp::ConstructHelpersL()

   173     {

   174 #ifdef _DEBUG

   175     RDebug::Printf( "CMemSpyEngineImp::ConstructHelpersL() - START" );

   176 #endif

   177 

   178 #ifdef _DEBUG

   179     RDebug::Printf( "CMemSpyEngineImp::ConstructHelpersL() - Heap..." );

   180 #endif

   181     iHelperHeap = CMemSpyEngineHelperHeap::NewL( iEngine );

   182 

   183 #ifdef _DEBUG

   184     RDebug::Printf( "CMemSpyEngineImp::ConstructHelpersL() - Stack..." );

   185 #endif

   186     iHelperStack = CMemSpyEngineHelperStack::NewL( iEngine );

   187 

   188 #ifdef _DEBUG

   189     RDebug::Printf( "CMemSpyEngineImp::ConstructHelpersL() - Code Segments..." );

   190 #endif

   191     iHelperCodeSegment = CMemSpyEngineHelperCodeSegment::NewL( iEngine );

   192 

   193 #ifdef _DEBUG

   194     RDebug::Printf( "CMemSpyEngineImp::ConstructHelpersL() - Chunk..." );

   195 #endif

   196     iHelperChunk = CMemSpyEngineHelperChunk::NewL( iEngine );

   197 

   198 #ifdef _DEBUG

   199     RDebug::Printf( "CMemSpyEngineImp::ConstructHelpersL() - Thread..." );

   200 #endif

   201     iHelperThread = CMemSpyEngineHelperThread::NewL( iEngine );

   202 

   203 #ifdef _DEBUG

   204     RDebug::Printf( "CMemSpyEngineImp::ConstructHelpersL() - Process..." );

   205 #endif

   206     iHelperProcess = CMemSpyEngineHelperProcess::NewL( iEngine );

   207 

   208 #ifdef _DEBUG

   209     RDebug::Printf( "CMemSpyEngineImp::ConstructHelpersL() - Server..." );

   210 #endif

   211     iHelperServer = CMemSpyEngineHelperServer::NewL( iEngine );

   212 

   213 #ifdef _DEBUG

   214     RDebug::Printf( "CMemSpyEngineImp::ConstructHelpersL() - AO..." );

   215 #endif

   216     iHelperActiveObject = CMemSpyEngineHelperActiveObject::NewL( iEngine );

   217 

   218 #ifdef _DEBUG

   219     RDebug::Printf( "CMemSpyEngineImp::ConstructHelpersL() - Kernel Containers..." );

   220 #endif

   221     iHelperKernelContainers = CMemSpyEngineHelperKernelContainers::NewL( iEngine );

   222 

   223 #ifdef _DEBUG

   224     RDebug::Printf( "CMemSpyEngineImp::ConstructHelpersL() - File System..." );

   225 #endif

   226     iHelperFileSystem = CMemSpyEngineHelperFileSystem::NewL( iEngine );

   227 

   228 #ifdef _DEBUG

   229     RDebug::Printf( "CMemSpyEngineImp::ConstructHelpersL() - ECOM..." );

   230 #endif

   231     iHelperECom = CMemSpyEngineHelperECom::NewL( iEngine );

   232 

   233 #ifdef _DEBUG

   234     RDebug::Printf( "CMemSpyEngineImp::ConstructHelpersL() - FBSERV..." );

   235 #endif

   236     iHelperFbServ = CMemSpyEngineHelperFbServ::NewL( iEngine );

   237 

   238 #ifdef _DEBUG

   239     RDebug::Printf( "CMemSpyEngineImp::ConstructHelpersL() - ROM..." );

   240 #endif

   241     iHelperROM = CMemSpyEngineHelperROM::NewL( iEngine );

   242 

   243 #ifdef _DEBUG

   244     RDebug::Printf( "CMemSpyEngineImp::ConstructHelpersL() - RAM..." );

   245 #endif

   246     iHelperRAM = CMemSpyEngineHelperRAM::NewL( iEngine );

   247 

   248 #ifdef _DEBUG

   249     RDebug::Printf( "CMemSpyEngineImp::ConstructHelpersL() - WindowServer..." );

   250 #endif

   251     

   252     TInt err = iHelperWindowServerLoader.Load( _L("memspywindowserverhelper.dll") );

   253 #ifdef _DEBUG

   254     RDebug::Printf( "CMemSpyEngineImp::ConstructHelpersL() - WindowServer load err: %d", err );

   255 #endif

   256     if ( !err )

   257         {

   258 #ifdef __WINS__ // ordinal is different 

   259         TLibraryFunction entry = iHelperWindowServerLoader.Lookup( 3 );

   260 #else

   261         TLibraryFunction entry = iHelperWindowServerLoader.Lookup( 1 );

   262 #endif

   263         if ( entry != NULL )

   264             {

   265             iHelperWindowServer = (MMemSpyEngineHelperWindowServer*) entry();

   266             }

   267         }

   268     

   269 #ifdef _DEBUG

   270     RDebug::Printf( "CMemSpyEngineImp::ConstructHelpersL() - CondVar..." );

   271 #endif

   272     iHelperCondVar = CMemSpyEngineHelperCondVar::NewL( iEngine );

   273 

   274 #ifdef _DEBUG

   275     RDebug::Printf( "CMemSpyEngineImp::ConstructHelpersL() - END" );

   276 #endif

   277     }

   278 

   279 

   280 RFs& CMemSpyEngineImp::FsSession()

   281     {

   282     return iFsSession;

   283     }

   284 

   285 

   286 CMemSpyEngineObjectContainer& CMemSpyEngineImp::Container()

   287     {

   288     __ASSERT_ALWAYS( iContainers.Count() >= 1, MemSpyEngineUtils::Panic( EMemSpyEnginePanicInvalidContainer1 ) );

   289     CMemSpyEngineObjectContainer* headContainer = iContainers[ 0 ];

   290     return *headContainer;

   291     }

   292 

   293 

   294 const CMemSpyEngineObjectContainer& CMemSpyEngineImp::Container() const

   295     {

   296     __ASSERT_ALWAYS( iContainers.Count() >= 1, MemSpyEngineUtils::Panic( EMemSpyEnginePanicInvalidContainer2 ) );

   297     const CMemSpyEngineObjectContainer* headContainer = iContainers[ 0 ];

   298     return *headContainer;

   299     }

   300 

   301 

   302 void CMemSpyEngineImp::SetObserver( MMemSpyEngineObserver* aObserver )

   303     {

   304     iObserver = aObserver;

   305     }

   306 

   307 

   308 void CMemSpyEngineImp::NotifyContainerChangeL()

   309     {

   310     if  ( iObserver )

   311         {

   312         iObserver->HandleMemSpyEngineEventL( MMemSpyEngineObserver::EHandleThreadsOrProcessesChanged, &Container() );

   313         }

   314     }

   315 

   316 

   317 void CMemSpyEngineImp::NotifyClientServerOperationRequestL( TInt aType )

   318     {

   319     if  ( iObserver )

   320         {

   321         iObserver->HandleMemSpyEngineEventL( MMemSpyEngineObserver::EHandleClientServerOperationRequest, reinterpret_cast< TAny* >( aType ) );

   322         }

   323     }

   324 

   325 

   326 CMemSpyEngineOutputSink& CMemSpyEngineImp::Sink()

   327     {

   328     return *iSink;

   329     }

   330 

   331 

   332 TMemSpySinkType CMemSpyEngineImp::SinkType()

   333     {

   334     return iSink->Type();

   335     }

   336 

   337 

   338 void CMemSpyEngineImp::InstallSinkL( TMemSpySinkType aType )

   339     {

   340 #ifdef _DEBUG

   341     RDebug::Printf( "CMemSpyEngineImp::InstallSinkL() - START - switching sink from %d to %d...", (iSink != NULL ? iSink->Type() : -1), aType );

   342 #endif

   343     //

   344     CMemSpyEngineOutputSink* sink = NULL;

   345     //

   346     switch( aType )

   347         {

   348     case ESinkTypeDebug:

   349         sink = CMemSpyEngineOutputSinkDebug::NewL( iEngine );

   350         break;

   351     case ESinkTypeFile:

   352         sink = CMemSpyEngineOutputSinkFile::NewL( iEngine );

   353         break;

   354         }

   355     //

   356     delete iSink;

   357     iSink = sink;

   358     //

   359 #ifdef _DEBUG

   360     RDebug::Printf( "CMemSpyEngineImp::InstallSinkL() - END - sink type: %d", iSink->Type() );

   361 #endif

   362     }

   363 

   364 

   365 void CMemSpyEngineImp::ListOpenFilesL()

   366     {

   367     HelperFileSystem().ListOpenFilesL();

   368     }

   369 

   370 

   371 void CMemSpyEngineImp::GetVersion( TVersion& aVersion )

   372     {

   373     iMemSpyDriver->GetVersion( aVersion );

   374     }

   375 

   376 

   377 TBool CMemSpyEngineImp::IsHelperWindowServerSupported()

   378     {

   379     return iHelperWindowServer != NULL;

   380     }

   381 

   382 

   383 CMemSpyEngineMidwife& CMemSpyEngineImp::Midwife()

   384     {

   385     return *iMidwife;

   386     }

   387 

   388 

   389 CMemSpyEngineUndertaker& CMemSpyEngineImp::Undertaker()

   390     {

   391     return *iUndertaker;

   392     }

   393 

   394 

   395 CMemSpyEngineChunkWatcher& CMemSpyEngineImp::ChunkWatcher()

   396     {

   397     return *iChunkWatcher;

   398     }

   399 

   400 

   401 CMemSpyEngineHelperHeap& CMemSpyEngineImp::HelperHeap()

   402     {

   403     return *iHelperHeap;

   404     }

   405 

   406 

   407 CMemSpyEngineHelperStack& CMemSpyEngineImp::HelperStack()

   408     {

   409     return *iHelperStack;

   410     }

   411 

   412 

   413 CMemSpyEngineHelperCodeSegment& CMemSpyEngineImp::HelperCodeSegment()

   414     {

   415     return *iHelperCodeSegment;

   416     }

   417 

   418 

   419 CMemSpyEngineHelperChunk& CMemSpyEngineImp::HelperChunk()

   420     {

   421     return *iHelperChunk;

   422     }

   423 

   424 

   425 CMemSpyEngineHelperThread& CMemSpyEngineImp::HelperThread()

   426     {

   427     return *iHelperThread;

   428     }

   429 

   430 

   431 CMemSpyEngineHelperProcess& CMemSpyEngineImp::HelperProcess()

   432     {

   433     return *iHelperProcess;

   434     }

   435 

   436 

   437 CMemSpyEngineHelperServer& CMemSpyEngineImp::HelperServer()

   438     {

   439     return *iHelperServer;

   440     }

   441 

   442 

   443 CMemSpyEngineHelperActiveObject& CMemSpyEngineImp::HelperActiveObject()

   444     {

   445     return *iHelperActiveObject;

   446     }

   447 

   448 

   449 CMemSpyEngineHelperKernelContainers& CMemSpyEngineImp::HelperKernelContainers()

   450     {

   451     return *iHelperKernelContainers;

   452     }

   453 

   454 

   455 CMemSpyEngineHelperFileSystem& CMemSpyEngineImp::HelperFileSystem()

   456     {

   457     return *iHelperFileSystem;

   458     }

   459 

   460 

   461 CMemSpyEngineHelperECom& CMemSpyEngineImp::HelperECom()

   462     {

   463     return *iHelperECom;

   464     }

   465 

   466 

   467 CMemSpyEngineHelperSysMemTracker& CMemSpyEngineImp::HelperSysMemTracker()

   468     {

   469     return *iHelperSysMemTracker;

   470     }

   471 

   472 

   473 CMemSpyEngineHelperFbServ& CMemSpyEngineImp::HelperFbServ()

   474     {

   475     return *iHelperFbServ;

   476     }

   477 

   478 

   479 CMemSpyEngineHelperROM& CMemSpyEngineImp::HelperROM()

   480     {

   481     return *iHelperROM;

   482     }

   483 

   484 

   485 CMemSpyEngineHelperRAM& CMemSpyEngineImp::HelperRAM()

   486     {

   487     return *iHelperRAM;

   488     }

   489 

   490 

   491 MMemSpyEngineHelperWindowServer& CMemSpyEngineImp::HelperWindowServer()

   492     {

   493     return *iHelperWindowServer;

   494     }

   495 

   496 

   497 CMemSpyEngineHelperCondVar& CMemSpyEngineImp::HelperCondVar()

   498     {

   499     return *iHelperCondVar;

   500     }

   501 

   502 

   503 RMemSpyDriverClient& CMemSpyEngineImp::Driver()

   504     {

   505     return *iMemSpyDriver;

   506     }

   507 

   508 

   509 TInt CMemSpyEngineImp::ProcessSuspendAndGetErrorLC( TProcessId aId )

   510     {

   511     __ASSERT_ALWAYS( iSuspendedProcess == aId || iSuspendedProcess == 0, MemSpyEngineUtils::Panic( EMemSpyEnginePanicSuspendRequest1 ) );

   512 

   513     TInt errorOrCount = Driver().ProcessThreadsSuspend( aId );

   514     if  ( errorOrCount >= 0 )

   515         {

   516         if  ( errorOrCount == 1 )

   517             {

   518             iSuspendedProcess = aId;

   519             }

   520         else

   521             {

   522             // Suspending already suspended process

   523             __ASSERT_ALWAYS( iSuspendedProcess == aId, MemSpyEngineUtils::Panic( EMemSpyEnginePanicSuspendRequest2 ) );

   524             }

   525         //

   526         CleanupStack::PushL( TCleanupItem( ResumeSuspendedProcess, this ) );

   527 

   528         if  ( errorOrCount == 1 )

   529             {

   530             iSink->ProcessSuspendedL( aId );

   531             }

   532             

   533         // At this point, all was well

   534         errorOrCount = KErrNone;

   535         }

   536 

   537     return errorOrCount;

   538     }

   539 

   540 

   541 void CMemSpyEngineImp::ProcessSuspendLC( TProcessId aId )

   542     {

   543     const TInt error = ProcessSuspendAndGetErrorLC( aId );

   544     User::LeaveIfError( error );

   545     }

   546 

   547 

   548 void CMemSpyEngineImp::ProcessResume()

   549     {

   550     const TUint id = iSuspendedProcess;

   551     //

   552     const TInt errorOrCount = Driver().ProcessThreadsResume( id );

   553     //

   554     if  ( errorOrCount == 0 )

   555         {

   556         iSink->ProcessResumed( id );

   557         iSuspendedProcess = 0;

   558         }

   559     }

   560     

   561 

   562 TProcessId CMemSpyEngineImp::SuspendedProcessId() const

   563     {

   564     return TProcessId( iSuspendedProcess );

   565     }

   566 

   567 

   568 void CMemSpyEngineImp::ResumeSuspendedProcess( TAny* aSelf )

   569     {

   570     CMemSpyEngineImp* self = reinterpret_cast< CMemSpyEngineImp* >( aSelf );

   571     self->ProcessResume();

   572     }

   573 

   574 

   575 void CMemSpyEngineImp::ThreadIsDeadL( const TThreadId& aId, const RThread& aThread )

   576     {

   577     if  ( aThread.Handle() != KNullHandle )

   578         {

   579         const TFullName name( aThread.FullName() );

   580         //

   581         TBuf<128> exitInfo;

   582         const TExitCategoryName exitCategory( aThread.ExitCategory() );

   583         CMemSpyThread::AppendExitInfo( exitInfo, aThread.ExitType(), aThread.ExitReason(), exitCategory );

   584         //

   585         _LIT( KMemSpyEventInfoText, "[MemSpy] Thread died: %S [%d - 0x%04x] %S" );

   586         Sink().OutputLineFormattedL( KMemSpyEventInfoText, &name, (TUint32) aId, (TUint32) aId, &exitInfo );

   587         }

   588     }

   589     

   590 

   591 void CMemSpyEngineImp::ProcessIsDeadL( const TProcessId& aId, const RProcess& aProcess )

   592     {

   593     if  ( aProcess.Handle() != KNullHandle )

   594         {

   595         const TFullName name( aProcess.FullName() );

   596         //

   597         TBuf<128> exitInfo;

   598         const TExitCategoryName exitCategory( aProcess.ExitCategory() );

   599         CMemSpyThread::AppendExitInfo( exitInfo, aProcess.ExitType(), aProcess.ExitReason(), exitCategory );

   600         //

   601         _LIT( KMemSpyEventInfoText, "[MemSpy] Process died: %S [%d - 0x%04x] %S" );

   602         Sink().OutputLineFormattedL( KMemSpyEventInfoText, &name, (TUint32) aId, (TUint32) aId, &exitInfo );

   603         }

   604     }

   605 

   606 

   607 void CMemSpyEngineImp::ThreadIsBornL( const TThreadId& aId, const RThread& aThread )

   608     {

   609     if  ( aThread.Handle() != KNullHandle )

   610         {

   611         const TFullName name( aThread.FullName() );

   612         //

   613         _LIT( KMemSpyEventInfoText, "[MemSpy] Thread created: %S (%d / 0x%08x)" );

   614         Sink().OutputLineFormattedL( KMemSpyEventInfoText, &name, (TUint32) aId, (TUint32) aId );

   615         }

   616     }

   617 

   618 

   619 void CMemSpyEngineImp::ProcessIsBornL( const TProcessId& aId, const RProcess& aProcess )

   620     {

   621     if  ( aProcess.Handle() != KNullHandle )

   622         {

   623         const TFullName name( aProcess.FullName() );

   624         //

   625         _LIT( KMemSpyEventInfoText, "[MemSpy] Process created: %S (%d / 0x%08x)" );

   626         Sink().OutputLineFormattedL( KMemSpyEventInfoText, &name, (TUint32) aId, (TUint32) aId );

   627         }

   628     }

   629 

   630 

   631