Tracee.hxx

#pragma once
 
// C++
#include <optional>
#include <vector>
 
// cosmos
#include <cosmos/compiler.hxx>
#include <cosmos/io/iovector.hxx>
#include <cosmos/proc/ptrace.hxx>
#include <cosmos/proc/signal.hxx>
#include <cosmos/proc/SigSet.hxx>
#include <cosmos/utils.hxx>
 
// forward declaration of low-level structures found in sys/user.h.
// avoid pulling in that low level header here, since this way of reading
// registers is not common anymore.
struct user_regs_struct;
struct user_fpregs_struct;
// seccomp instruction
struct sock_filter;
 
#ifdef COSMOS_X86
struct user_desc;
#endif
 
namespace cosmos {
 
struct InputMemoryRegion;
class SigInfo;
 
 
class COSMOS_API Tracee {
public: // types
 
 
        enum class RestartMode {
                CONT              = to_integral(ptrace::Request::CONT),
                DETACH            = to_integral(ptrace::Request::DETACH),
                SYSCALL           = to_integral(ptrace::Request::SYSCALL),
                SINGLESTEP        = to_integral(ptrace::Request::SINGLESTEP),
#ifdef PTRACE_SYSEMU
                SYSEMU            = to_integral(ptrace::Request::SYSEMU),
                SYSEMU_SINGLESTEP = to_integral(ptrace::Request::SYSEMU_SINGLESTEP),
#endif
                LISTEN            = to_integral(ptrace::Request::LISTEN)
        };
 
public: // functions
 
        explicit Tracee(const ProcessID pid = ProcessID::INVALID) :
                        m_pid{pid}
        {}
 
        ProcessID pid() const {
                return m_pid;
        }
 
        bool valid() const {
                return pid() != ProcessID::INVALID;
        }
 
 
        void seize(const ptrace::Opts opts) {
                this->request(ptrace::Request::SEIZE, nullptr, opts.raw());
        }
 
 
        void attach() {
                this->request(ptrace::Request::ATTACH);
        }
 
 
        void detach() {
                this->request(ptrace::Request::DETACH);
        }
 
 
        void restart(const RestartMode mode, const std::optional<Signal> signal = {}) {
                // data here takes the plain signal number, 0 means "don't inject a signal".
                this->request(static_cast<ptrace::Request>(mode),
                                nullptr,
                                mode != RestartMode::LISTEN && signal ? signal->raw() : SignalNr{0});
        }
 
 
        void interrupt() {
                this->request(ptrace::Request::INTERRUPT);
        }
 
 
        void setOptions(const ptrace::Opts opts) {
                this->request(ptrace::Request::SETOPTIONS, nullptr, opts.raw());
        }
 
 
        long peekData(const long *addr) const {
                return *(this->request(ptrace::Request::PEEKDATA, addr));
        }
 
        void pokeData(const long *addr, long value) {
                this->request(ptrace::Request::POKEDATA, addr, value);
        }
 
 
        long peekUser(const long *offset) const {
                return *(this->request(ptrace::Request::PEEKUSER, offset));
        }
 
 
        void pokeUser(const long *offset, long value) {
                this->request(ptrace::Request::POKEUSER, offset, value);
        }
 
 
        void getRegisters(struct user_regs_struct &out) const {
                // NOTE: on Sparc the address needs to be passed as third
                // argument, not as fourth. If we should ever want to support
                // it, we'd need an #ifdef of some sort.
                this->request(ptrace::Request::GETREGS, nullptr, &out);
        }
 
 
        void setRegisters(const struct user_regs_struct &out) {
                // NOTE: see getRegisters() about Sparc architecture
                this->request(ptrace::Request::SETREGS, nullptr, &out);
        }
 
 
        void getFloatRegisters(struct user_fpregs_struct &out) const {
                // NOTE: see getRegisters() about Sparc architecture
                this->request(ptrace::Request::GETFPREGS, nullptr, &out);
        }
 
 
        void setFloatRegisters(const struct user_fpregs_struct &out) {
                this->request(ptrace::Request::SETFPREGS, nullptr, &out);
        }
 
 
        void getRegisterSet(const ptrace::RegisterType type, InputMemoryRegion &iovec) const {
                this->request(ptrace::Request::GETREGSET, type, iovec.asIovec());
        }
 
        void setRegisterSet(const ptrace::RegisterType type, OutputMemoryRegion &iovec) {
                this->request(ptrace::Request::SETREGSET, type, iovec.asIovec());
        }
 
        void getSigInfo(SigInfo &info) const;
 
 
        void setSigInfo(const SigInfo &info);
 
 
        std::vector<SigInfo> peekSigInfo(const ptrace::PeekSigInfo &settings);
 
        void getSigMask(SigSet &set) const {
                this->request(ptrace::Request::GETSIGMASK, sizeof(*set.raw()), set.raw());
        }
 
        void setSigMask(const SigSet &set) {
                this->request(ptrace::Request::SETSIGMASK, sizeof(*set.raw()), set.raw());
        }
 
 
        ProcessID getPIDEventMsg() const {
                const auto pid = getEventMsg();
                return static_cast<ProcessID>(pid);
        }
 
 
        ExitStatus getExitEventMsg() const {
                const auto status = getEventMsg();
                return static_cast<ExitStatus>(status);
        }
 
 
        uint16_t getSeccompRetDataEventMsg() const {
                const auto seccomp_ret_data = getEventMsg();
                return static_cast<uint16_t>(seccomp_ret_data);
        }
 
 
        void getSeccompFilter(std::vector<struct sock_filter> &instructions, const unsigned long prog_index) const;
 
#ifdef COSMOS_X86
 
        // these operations are also supported on MIPS, m68k and C-SKY but
        // they're using different data structures.
        // for the definition of `struct user_desc` you need to include <asm/ldt.h>.
 
 
        void getThreadArea(struct user_desc &desc) const;
 
 
        void setThreadArea(const struct user_desc &desc);
 
#endif // X86
 
 
        void getSyscallInfo(ptrace::SyscallInfo &info) const;
 
protected: // functions
 
 
        unsigned long getEventMsg() const {
                unsigned long msg = 0;
                this->request(ptrace::Request::GETEVENTMSG, nullptr, &msg);
                return msg;
        }
 
        template <typename ADDR=void*, typename DATA=void*>
        std::optional<long> request(const ptrace::Request req, ADDR addr = nullptr, DATA data = nullptr) const {
                // First cast to const void* then remove const, this allows to
                // pass in const pointers. The compiler cannot understand that
                // ptrace() won't change the pointed-to data according to
                // contract.
                return cosmos::ptrace::trace(req, m_pid,
                                const_cast<void*>(reinterpret_cast<const void*>(addr)),
                                const_cast<void*>(reinterpret_cast<const void*>(data)));
        }
 
        /*
         * Template specialization in case `nullptr` is passed for addr.
         * This avoids invalid cast from nullptr_t to void* errors.
         */
        template <typename DATA=void*>
        std::optional<long> request(const ptrace::Request req, std::nullptr_t, DATA data = nullptr) const {
                return request(req, static_cast<void*>(nullptr), data);
        }
 
protected: // data
 
        ProcessID m_pid;
};
 
} // end ns