SystemCall.hxx

#pragma once
 
// C++
#include <iosfwd>
#include <memory>
#include <optional>
#include <string_view>
#include <vector>
 
// cosmos
#include <cosmos/error/RuntimeError.hxx>
#include <cosmos/proc/ptrace.hxx>
 
// clues
#include <clues/ErrnoResult.hxx>
#include <clues/items/error.hxx>
#include <clues/sysnrs/fwd.hxx>
#include <clues/types.hxx>
#include <clues/utils.hxx>
 
namespace clues {
        class SystemCall;
        class SystemCallInfo;
        class Tracee;
}
 
std::ostream& operator<<(std::ostream &o, const clues::SystemCall &sc);
 
namespace clues {
 
class SystemCallItem;
using SystemCallPtr = std::shared_ptr<SystemCall>;
using SystemCallItemPtr = SystemCallItem*;


class CLUES_API SystemCall {
        friend std::ostream& ::operator<<(std::ostream&, const SystemCall&);
public: // types

        using ParameterVector = std::vector<SystemCallItemPtr>;
 
public: // functions


        SystemCall(const SystemCallNr nr);
 
        virtual ~SystemCall() {}
 
        // mark as non-copyable
        SystemCall(const SystemCall &other) = delete;
        SystemCall& operator=(const SystemCall &other) = delete;


        void setEntryInfo(const Tracee &proc, const SystemCallInfo &info);


        void setExitInfo(const Tracee &proc, const SystemCallInfo &info);

        std::string_view name() const { return m_name; }
        size_t numPars() const { return m_pars.size(); }
        SystemCallNr callNr() const { return m_nr; }

        const ParameterVector& parameters() const { return m_pars; }
        SystemCallItemPtr result() const { return hasResultValue() ? m_return : nullptr; }
        std::optional<ErrnoResult> error() const { return m_error; }
 
        bool hasOutParameter() const;
 
        bool hasResultValue() const {
                return m_error == std::nullopt;
        }
 
        bool hasErrorCode() const {
                return !hasResultValue();
        }

        ABI abi() const {
                return m_abi;
        }
 
        bool is32BitEmulationABI() const {
                return get_default_abi() == ABI::X86_64 && abi() == ABI::I386;
        }


        static const char* name(const SystemCallNr nr);

        static bool validNr(const SystemCallNr nr);


        const SystemCallInfo* currentInfo() const {
                return m_info;
        }
 
protected: // functions
 
        void fillParameters(const Tracee &proc, const SystemCallInfo &info);


        void setReturnItem(SystemCallItem &ret) {
                m_return = &ret;
                m_return->setSystemCall(*this);
                if (!ret.isReturnValue()) {
                        throw cosmos::RuntimeError{"added non-return-value as return item"};
                }
        }
 
        void addParameters() {}
 
        template <typename T, typename... Targs>
        void addParameters(T &par, Targs& ...rest) {
                par.setSystemCall(*this);
                m_pars.push_back(&par);
                addParameters(rest...);
        }
 
        template <typename... Targs>
        void setParameters(Targs& ...args) {
                m_pars.clear();
                addParameters(args...);
        }


        virtual bool check2ndPass(const Tracee &) { return false; };

        virtual void prepareNewSystemCall() {}


        virtual void updateFDTracking(const Tracee &proc) { (void)proc; }
 
        /*
         * these are wrappers to make use of SystemCall's friendship towards
         * Tracee, since specializations wouldn't be allowed to call
         * `Tracee::dropFD` etc.
         */
 
        void dropFD(const Tracee &proc, const cosmos::FileNum num);
 
        void trackFD(const Tracee &proc, FDInfo &&info);
 
protected: // data

        SystemCallNr m_nr;
        const std::string_view m_name;
        const SystemCallInfo *m_info = nullptr;
        SystemCallItemPtr m_return;
        std::optional<ErrnoResult> m_error;
        ParameterVector m_pars;
        ABI m_abi = ABI::UNKNOWN;
};

CLUES_API SystemCallPtr create_syscall(const SystemCallNr nr);
 
} // end ns