Engine.hxx

#pragma once
 
// C++
#include <map>
#include <memory>
#include <optional>
 
// cosmos
#include <cosmos/BitMask.hxx>
#include <cosmos/proc/ptrace.hxx>
#include <cosmos/proc/types.hxx>
#include <cosmos/string.hxx>
 
// clues
#include <clues/types.hxx>
 
namespace cosmos {
        struct ChildState;
}
 
namespace clues {
 
class Tracee;
class EventConsumer;
class SystemCall;


class CLUES_API Engine {
        friend class Tracee;
public: // types
 
        enum class FormatFlag : uint64_t {
                FD_INFO = 1, 
        };
 
        using FormatFlags = cosmos::BitMask<FormatFlag>;
 
public: // functions

        explicit Engine(EventConsumer &consumer) :
                        m_consumer{consumer} {
        }


        virtual ~Engine();


        TraceePtr addTracee(const cosmos::ProcessID pid, const FollowChildren follow_children,
                        const AttachThreads attach_threads, const cosmos::ProcessID sibling = cosmos::ProcessID::INVALID);


        TraceePtr addTracee(const cosmos::StringVector &cmdline, const FollowChildren follow_children);


        void trace();


        void stop(const std::optional<cosmos::Signal> signal);
 
        FormatFlags formatFlags() const {
                return m_format_flags;
        }


        void setFormatFlags(const FormatFlags flags) {
                m_format_flags = flags;
        }
 
protected: // types
 
        using TraceeMap = std::map<cosmos::ProcessID, TraceePtr>;
 
        using EventMap = std::map<cosmos::ProcessID, cosmos::ChildState>;

        enum class Decision {
                RETRY, 
                DROP, 
                STORE, 
                DONE, 
        };
 
protected: // functions
 
        void checkCleanupTracee(TraceeMap::iterator it);
 
        void checkUnknownEvents();
 
        Decision handleEvent(const cosmos::ChildState &data);
 
        void handleNoChildren();


        Decision checkUnknownTraceeEvent(const cosmos::ChildState &data);
 
        bool tryUpdateTraceePID(const cosmos::ProcessID old_pid, const cosmos::ProcessID new_pid);


        void handleAutoAttach(Tracee &parent, const cosmos::ProcessID pid,
                        const cosmos::ptrace::Event event, const SystemCall &sc);

        TraceePtr handleSubstitution(const cosmos::ProcessID old_pid);
 
protected: // data

        TraceeMap m_tracees;
        EventMap m_unknown_events;
        cosmos::ProcessID m_newly_attached_pid = cosmos::ProcessID::INVALID;
        EventConsumer &m_consumer;
        FormatFlags m_format_flags;
};
 
} // end ns