types.hxx

#pragma once
 
// Linux
#include <sys/procfs.h> // the elf_greg_t & friends are in here
 
// C++
#include <cstdint>
#include <map>
#include <memory>
#include <optional>
#include <string>
 
// cosmos
#include <cosmos/utils.hxx>
#include <cosmos/fs/types.hxx>
 
namespace clues {
 
/*
 * some general types used across Clues
 */

using FollowChildren = cosmos::NamedBool<struct follow_children_t, true>;

using AttachThreads = cosmos::NamedBool<struct attach_threads_t, true>;
 
class Tracee;
 
using TraceePtr = std::shared_ptr<Tracee>;
 
class ProcessData;
 
using ProcessDataPtr = std::shared_ptr<ProcessData>;

enum class Word : elf_greg_t {
        ZERO = 0
};


enum class KernelErrno : int {
        RESTART_SYS          = 512, /* transparent restart if SA_RESTART is set, otherwise EINTR return */
        RESTART_NOINTR       = 513, /* always transparent restart */
        RESTART_NOHAND       = 514, /* restart if no handler.. */
        RESTART_RESTARTBLOCK = 516, /* restart by calling sys_restart_syscall */
};


enum class ABI {
        UNKNOWN,
        X86_64,
        I386,
        X32,    
        AARCH64
};


struct FDInfo {
public: // types


        enum class Type {
                INVALID,
                FS_PATH, 
                EVENT_FD, 
                TIMER_FD, 
                SIGNAL_FD, 
                SOCKET, 
                EPOLL, 
                PIPE, 
                INOTIFY, 
                PID_FD, 
                BPF_MAP, 
                BPF_PROG, 
                PERF_EVENT,
                UNKNOWN
        };
 
public: // functions
 
        FDInfo() = default;
 
        explicit FDInfo(const Type _type, const cosmos::FileNum _fd) :
                type{_type}, fd{_fd} {
        }
 
        bool valid() const {
                return type != Type::INVALID;
        }
 
public: // data
 
        Type type = Type::INVALID;
        cosmos::FileNum fd = cosmos::FileNum::INVALID; 
        std::string path; 
        std::optional<cosmos::OpenMode> mode;
        std::optional<cosmos::OpenFlags> flags;
        std::optional<cosmos::Inode> inode; 
};

using FDInfoMap = std::map<cosmos::FileNum, FDInfo>;

enum class Base {
        OCT,
        DEC,
        HEX
};


enum class ForeignPtr : uintptr_t {
        NO_POINTER = 0
};
 
} // end ns

inline clues::ForeignPtr operator++(clues::ForeignPtr &p, int) {
        auto ret = p;
        p = clues::ForeignPtr{static_cast<uintptr_t>(p) + sizeof(void*)};
        return ret;
}