RTDebugger.h

/*
 * Licensed Materials - Property of HCL and/or IBM
 * Copyright HCL Technologies Ltd. 2016, 2021. All Rights Reserved.
 * Copyright IBM Corporation 1999, 2016. All Rights Reserved.
 *
 * U.S. Government Users Restricted Rights -  Use, duplication or 
 * disclosure restricted by GSA ADP Schedule.
 */
 
#ifndef __RTDebugger_h__
#define __RTDebugger_h__ included
 
#ifdef PRAGMA
#pragma interface
#endif
 
#ifndef __RTConfig_h__
#include <RTConfig.h>
#endif
 
#if OTRTSDEBUG != DEBUG_NONE
 
#ifndef __RTController_h__
#include <RTController.h>
#endif
 
#ifndef __RTDebuggerInput_h__
#include <RTDebuggerInput.h>
#endif
 
#ifndef __RTElasticArray_h__
#include <RTElasticArray.h>
#endif
 
#ifndef __RTTcpSocket_h__
#include <RTTcpSocket.h>
#endif
 
#ifndef __RTTimespec_h__
#include <RTTimespec.h>
#endif
 
#if USE_THREADS && ! defined( __RTinet_h__ )
#include <RTinet.h>
#endif
 
class RTActor;
class RTActorRef;
class RTDaemonInfo;
class RTEventInfo;
class RTIOMonitor;
class RTObserver;
class RTProbe;
class RTProtocol;
class RTSequenceOf;
class RTDiagStream;
 
class RTDebugger : public RTJob
{
private:
    enum TraceCategory
    {
    TraceComm,
    TraceException,
    TraceFrame,
    TraceLayer,
    TraceTimer,
    TraceSystem
    };
 
    enum
    {
    TraceAll = TraceSystem + 1
    };
 
    // if mode is Stepping we stop it after step_count message events
    enum
    {
    Halted,
    Stepping,
    Running
    }                   mode;
 
    RTController      * tasks;
 
    RTDebuggerInput     input;
 
    unsigned            step_count;
 
    RTMessage         * freeList;
    unsigned            freeListSize;
 
#if OBSERVABLE
    RTProbe           * getProbe( int );
    RTElasticArray      probes;
    RTElasticArray      parkedProbes;
    int                 nrParkedProbes;
    RTTimespec          lastTimestamp;
    RTTimespec          zeroTimeBase;
 
    RTTcpSocket         listener;
    RTIOMonitor       * ioMonitor;
 
#if USE_THREADS
    // This is the descriptor of a UDP socket connected to itself, used to
    // allow another thread to interrupt us while we are executing 'idle'.
    int                 _udp;
    RTinet_port         _udp_port;
 
#ifdef TARGET_PSOS
    // On pSOS, other tasks cannot simply write a datagram on my UDP socket.
    // I have to create a 'trigger' task with which I share that socket.
    // Only it will write datagrams in response to 'wakeup' events that can
    // be sent by any task. This pointer refers to the object used to manage
    // that extra task.
    void              * _trigger;
#endif
 
    void                startupUdp( void );
    void                shutdownUdp( void );
    void                wakeupUdp( void );
#endif // USE_THREADS
 
    RTEventInfo       * eventHead;
    RTEventInfo       * eventTail;
 
    RTElasticArray      sockets;
    RTElasticArray      observers;
#endif // OBSERVABLE
 
    RTMessage         * newMsg( void );
    void                freeMsg( RTMessage * );
 
    unsigned char       traceLevel[ TraceAll ];
 
    enum Command
    {
    CmdInvalid, CmdNone
      , CmdAttach
      , CmdCont
      , CmdDetach
      , CmdExit
      , CmdGo
      , CmdHelp
      , CmdInfo
      , CmdLog
      , CmdMessage
      , CmdQuit
      , CmdSaps
      , CmdStats
      , CmdStep
      , CmdStop
      , CmdSystem
      , CmdTasks
      , CmdTrace
    };
 
 
    void            doCmd( void );
    void            doCmdQuit( void );
    void            doCmdSystem( void );
 
    void            printActor( const RTActor * );
    void            printPort( const RTProtocol *, int );
    void            printRef( const RTActor *, const char * );
    void            traceHelper( RTDiagStream& out,
                                 const char* prim_name,
                                 int info_type,
                                 const char* errorDescription,
                                 const void* info,
                                 const void* detail );
 
    int             getCommand( void );
    int             getCategory( void );
    int             getLevel( void );
 
    void            printHelp( void );
    void            printStructure( RTActor *, const char *, int );
    void            printActorInfo( RTActor * );
 
    RTActor       * getActor( void );
 
    RTActor       * findActor( const char *, RTActorRef * );
 
#if USE_THREADS
    void            wakeup( RTController * );
#endif
 
    int             useEvent( void );
    void            dispatchEvent( RTEventInfo * );
 
public:
            RTDebugger( void );
    virtual         ~RTDebugger( void );
 
    RTController  * getTask(int);
    void            debugIt( const char * cmdLine = nullptr );
    virtual void    mainLoop( void ) override;
    virtual void    kill( void ) override;
    virtual const char * name( void ) const override;
 
 
    void            doCmdExit( void );
    void            trace( RTController::Primitive,
               const char              * errorDescription,
               const void              * info,
               const void              * detail );
    void            logMessage( const RTMessage * );
 
    void            registerRTS( RTController * );
    void            attach( RTController * );
    void            detach( RTController * );
    void            deregisterRTS( RTController * );
 
    void            printMessage( const RTMessage * );
 
    RTS_INLINE int  controlThreshold( void ) const;
 
    int             step_begin( RTController * );
    void            step_end( RTController * );
 
    void            step( unsigned count = 1U );
    void            proceed( void );
 
#if ! USE_THREADS
    RTS_INLINE int  isHalted( void ) const;
#endif
 
#if OBSERVABLE
    void            actorIncarnated( RTActor * );
    void            actorDestroyed ( RTActor * );
    int             breakPoint( RTController *, RTEventInfo * );
 
    void            setTimestamp( RTMessage        *,
                  const RTProtocol * source,
                  int                sourceIndex );
    void            getTimestamp( RTTimespec & );
 
    void            checkObservability( void );
    void            closeObservability( void );
    int             mainObserverLoop( void );
    RTTcpSocket   * newConnection( void );
 
    RTObserver    * findObserver( RTTcpSocket *, int obsNr );
 
    int             addProbe( RTSequenceOf * probeInfo );
    int             addProbe( RTDaemonInfo * probeInfo );
    void            probeCreated( int probeId, RTProbe * );
    void            sendProbeSignal( RTActor *, int priority );
    int             deleteProbe( int );
 
    void            getHistory  ( int probeNr, int state );
    void            getPresence ( int probeNr, int observerId, int daemonId );
    void            getReference( int probeNr, int observerId );
 
    int             addEvent( RTEventInfo * );
 
    int             evtHistory( int             probeNr,
                int             actorIndex,
                const RTActor * actor,
                int             stateTarget,
                int             histHist,
                int             histCurr );
    int             evtPresence( int             probeNr,
                 int             actorIndex,
                 const RTActor * actor,
                 int             observerId,
                 int             daemonId );
    int             evtReference( int             probeNr,
                  const RTActor * actor,
                  int             compIndex,
                  int             nrIncarns,
                  int             observerId );
 
    void            evtRtsStatus( int observerId = -1 );
 
    int             evtVariable( int             probeNr,
                 int             actorIndex,
                 const RTActor * actor,
                 const char    * varName,
                 const char    * varValue );
 
    int             evtChildren( int             probeNr,
                 int             actorIndex,
                 const char    * actorID,
                 const char    * classID, 
                 const char    * data 
                 );
 
    void            evtMsgQueues( void );
 
    void            addFieldValue( const char * variable,
                   const char * value,
                   int          probeNr );
 
    void            probeAttention( const RTActor * target );
 
    int             inject( int                    inwards,
                const char           * signal,
                int                    prio,
                const void           * data,
                const RTObject_class * type,
                const RTDaemonInfo   & daemonInfo );
 
    int             doInject( RTProtocol           * port,
                  int                    index,
                  int                    signal,
                  int                    prio,
                  const void           * data,
                  const RTObject_class * type );
 
    int             getMessages( const RTDaemonInfo & daemonInfo );
 
    void            addFieldMonitor( int          probeNr,
                                     const char * variable );
    void            delFieldMonitor( int          probeNr,
                                     const char * variable );
#endif // OBSERVABLE
 
private:
    // unavailable methods
    RTDebugger( const RTDebugger & );
    RTDebugger & operator=( const RTDebugger & );
}; //lint !e1712
 
#if RTS_INLINES
#include <RTDebugger.inl>
#endif
 
#endif // OTRTSDEBUG != DEBUG_NONE
 
#endif // __RTDebugger_h__