clone.hxx

#pragma once
 
// C++
#include <optional>
 
// cosmos
#include <cosmos/proc/clone.hxx>
 
// clues
#include <clues/SystemCallItem.hxx>
 
namespace clues::item {
 
class CLUES_API CloneFlagsValue :
                        public SystemCallItem {
public: // functions
 
        explicit CloneFlagsValue() :
                        SystemCallItem{ItemType::PARAM_IN, "flags", "clone flags"} {
        }
 
        std::string str() const override;
 
        cosmos::CloneFlags flags() const {
                return m_flags;
        }
 
        std::optional<cosmos::SignalNr> exitSignal() const {
                return exit_signal;
        }
 
protected: // functions
 
        void processValue(const Tracee&) override;
 
protected: // data
 
        cosmos::CloneFlags m_flags;
        std::optional<cosmos::SignalNr> exit_signal;
};

class CLUES_API CloneArgs :
                public SystemCallItem {
public: // functions
 
        explicit CloneArgs() :
                        SystemCallItem{ItemType::PARAM_IN_OUT, "cl_args", "clone arguments"} {
 
        }


        const std::optional<cosmos::CloneArgs>& args() const {
                return m_args;
        }


        cosmos::FileNum pidfd() const {
                return m_pidfd;
        }


        cosmos::FileNum cgroup2fd() const {
                return m_cgroup2_fd;
        }


        cosmos::ThreadID tid() const {
                return m_child_tid;
        }
 
        std::string str() const override;
 
        void processValue(const Tracee&) override;
 
        void updateData(const Tracee &proc) override;
 
protected: // functions
 
        bool verifySize() const;
 
        void resetArgs();
 
protected: // data
 
        std::optional<cosmos::CloneArgs> m_args;
        cosmos::FileNum m_pidfd = cosmos::FileNum::INVALID;
        cosmos::FileNum m_cgroup2_fd = cosmos::FileNum::INVALID;
        cosmos::ThreadID m_child_tid = cosmos::ThreadID::INVALID;
        std::vector<cosmos::ThreadID> m_tid_array;
};
 
} // end ns