SigInfo.hxx

Go to the documentation of this file.

#pragma once
 
// C++
#include <optional>
 
// Linux
// this contains SYS_SECCOMP but the header has conflicts with user space
// headers for some time already, there seems to be no way around it:
//     https://bugzilla.kernel.org/show_bug.cgi?id=200081
// We define the constant ourselves further below.
//#include <linux/signal.h>
 
// cosmos
#include <cosmos/error/errno.hxx>
#include <cosmos/fs/types.hxx>
#include <cosmos/io/types.hxx>
#include <cosmos/memory.hxx>
#include <cosmos/proc/ptrace.hxx>
#include <cosmos/proc/signal.hxx>
#include <cosmos/proc/types.hxx>
#include <cosmos/time/types.hxx>
#include <cosmos/utils.hxx>
 
#ifndef SYS_SECCOMP
#       define SYS_SECCOMP 1
#endif
 
namespace cosmos {
 
 
class COSMOS_API SigInfo {
public: // types
 
        enum class Source : int {
                USER    = SI_USER,    
                KERNEL  = SI_KERNEL,  
                QUEUE   = SI_QUEUE,   
                TIMER   = SI_TIMER,   
                MESGQ   = SI_MESGQ,   
                ASYNCIO = SI_ASYNCIO, 
                QSIGIO  = SI_SIGIO,   
                TKILL   = SI_TKILL,   
        };
        enum class Source : int {…};
 
 
        struct ProcessCtx{
                ProcessID pid; 
                UserID uid;    
        };
        struct ProcessCtx {…};
 
 
        struct CustomData {
        public: // functions
 
                explicit CustomData(union sigval val) : m_val{val} {}
 
 
                int asInt() const {
                        return m_val.sival_int;
                }
                int asInt() const  {…}
 
 
                void* asPtr() const {
                        return m_val.sival_ptr;
                }
                void* asPtr() const  {…}
 
        protected: // data
 
                union sigval m_val;
        };
        struct CustomData {…};
 
        struct UserSigData {
                ProcessCtx sender;
        };
        struct UserSigData {…};
 
        struct QueueSigData {
                ProcessCtx sender;
 
                CustomData data;
        };
        struct QueueSigData {…};
 
        struct MsgQueueData {
                ProcessCtx msg_sender;
 
                CustomData data;
        };
        struct MsgQueueData {…};
 
        /*
         * TODO: this contains CustomData which is actually the ID returned from timer_create().
         * We need to model types for `timer_create()` first to make use of
         * that.
         */
        struct TimerData {
        public: // types
 
                enum class TimerID : int {};
 
        public: // functions
 
 
                TimerID id;
 
 
                int overrun;
        };
        struct TimerData {…};
 
 
        struct FaultData {
 
                void *addr;
        };
        struct FaultData {…};
 
        struct IllData : public FaultData {
        public: // types
 
                enum class Reason : int {
                        OPCODE    = ILL_ILLOPC,   
                        OPERAND   = ILL_ILLOPN,   
                        ADDRESS   = ILL_ILLADR,   
                        TRAP      = ILL_ILLTRP,   
                        PRIV_OP   = ILL_PRVOPC,   
                        PRIV_REG  = ILL_PRVREG,   
                        COPROC    = ILL_COPROC,   
                        BAD_STACK = ILL_BADSTK,   
                        BAD_IADDR = ILL_BADIADDR, 
                };
                enum class Reason : int {…};
 
        public: // data
 
                Reason reason;
        };
        struct IllData : public FaultData {…};
 
        struct FPEData : public FaultData {
        public: // types
 
                enum class Reason : int {
                        INT_DIV_ZERO    = FPE_INTDIV, 
                        INT_OVERFLOW    = FPE_INTOVF, 
                        FLOAT_DIV_ZERO  = FPE_FLTDIV, 
                        FLOAT_OVERFLOW  = FPE_FLTOVF, 
                        FLOAT_UNDERFLOW = FPE_FLTUND, 
                        FLOAT_INEXACT   = FPE_FLTRES, 
                        FLOAT_INVALID   = FPE_FLTINV, 
                        FLOAT_SUB_RANGE = FPE_FLTSUB, 
                        FLOAT_UNKNOWN   = FPE_FLTUNK, 
                        FLOAT_CONDTRAP  = FPE_CONDTRAP, 
                };
                enum class Reason : int {…};
 
        public: // data
 
                Reason reason;
        };
        struct FPEData : public FaultData {…};
 
        struct SegfaultData : public FaultData {
        public: // types
 
                enum class Reason : int {
                        MAP_ERROR      = SEGV_MAPERR, 
                        ACCESS_ERROR   = SEGV_ACCERR, 
                        BOUND_ERROR    = SEGV_BNDERR, 
                        PROT_KEY_ERROR = SEGV_PKUERR, 
                        ACCESS_ADI     = SEGV_ACCADI, 
                        MCD_DISRUPT    = SEGV_ADIDERR, 
                        PRECISE_MCD    = SEGV_ADIPERR, 
                        ASYNC_MTE      = SEGV_MTEAERR, 
                        SYNC_MTE       = SEGV_MTESERR, 
                        CPROT_ERROR    = SEGV_CPERR,   
                };
                enum class Reason : int {…};
 
                struct Bound {
                        void *lower = nullptr;
                        void *upper = nullptr;
                };
                struct Bound {…};
 
                // TODO: this is preliminary strong type that should be moved into a pkey() API wrapper.
                enum class ProtectionKey : unsigned int {
                };
 
        public: // data
 
                Reason reason;
                std::optional<Bound> bound;
                std::optional<ProtectionKey> key;
        };
        struct SegfaultData : public FaultData {…};
 
        struct BusData : public FaultData {
        public: // types
 
                enum class Reason : int {
                        ALIGNMENT           = BUS_ADRALN,   
                        NOT_EXISTING        = BUS_ADRERR,   
                        OBJECT_ERROR        = BUS_OBJERR,   
                        MCE_ACTION_REQUIRED = BUS_MCEERR_AR, 
                        MCE_ACTION_OPTIONAL = BUS_MCEERR_AO, 
                };
                enum class Reason : int {…};
 
        public: // data
 
                Reason reason;
                std::optional<short> addr_lsb;
        };
        struct BusData : public FaultData {…};
 
        struct ChildData {
        public: // types
 
                enum class Event : int {
                        INVALID   = -1,
                        EXITED    = CLD_EXITED,   
                        KILLED    = CLD_KILLED,   
                        DUMPED    = CLD_DUMPED,   
                        TRAPPED   = CLD_TRAPPED,  
                        STOPPED   = CLD_STOPPED,  
                        CONTINUED = CLD_CONTINUED 
                };
                enum class Event : int {…};
 
        public: // functions
 
                bool exited() const { return event == Event::EXITED; }
 
                bool killed() const { return event == Event::KILLED; }
 
                bool dumped() const { return event == Event::DUMPED; }
 
                bool trapped() const { return event == Event::TRAPPED; }
 
                bool continued() const { return event == Event::CONTINUED; }
 
                bool stopped() const { return event == Event::STOPPED; }
 
                bool exitedSuccessfully() const {
                        return exited() && *status == ExitStatus::SUCCESS;
                }
                bool exitedSuccessfully() const  {…}
 
                bool signaled() const {
                        return event == Event::KILLED ||
                                event == Event::DUMPED ||
                                event == Event::STOPPED ||
                                event == Event::CONTINUED;
                }
                bool signaled() const  {…}
 
                bool valid() const {
                        return event != Event::INVALID;
                }
                bool valid() const  {…}
 
                void reset() {
                        event = Event::INVALID;
                        child.pid = ProcessID::INVALID;
                        status = std::nullopt;
                        signal = std::nullopt;
                }
 
        public: // data
 
                Event event;
                ProcessCtx child;
 
 
                std::optional<ExitStatus> status;
 
 
                std::optional<Signal> signal;
 
 
                std::optional<ClockTicks> user_time;
 
 
                std::optional<ClockTicks> system_time;
        };
        struct ChildData {…};
 
        struct SysData {
        public: // types
 
                enum class Reason : int {
                        // TODO: check what happens for non-seccomp SIGSYS
                        SECCOMP = SYS_SECCOMP, 
                };
                enum class Reason : int {…};
 
        public: // data
 
                Reason reason;
                void *call_addr;
                int call_nr;
                ptrace::Arch arch;
                Errno error;
        };
        struct SysData {…};
 
        struct PollData {
        public: // types
 
                enum class Reason : int {
                        INPUT    = POLL_IN,  
                        OUTPUT   = POLL_OUT, 
                        MESSAGE  = POLL_MSG, 
                        ERROR    = POLL_ERR, 
                        PRIORITY = POLL_PRI, 
                        HANGUP   = POLL_HUP, 
                };
                enum class Reason : int {…};
 
        public: // data
 
                Reason reason;
                FileNum fd;
                PollEvents events;
        };
        struct PollData {…};
 
public: // functions
 
        SigInfo() {
                clear();
        }
        SigInfo() {…}
 
 
        SigInfo(const no_init_t) {}
 
        Signal sigNr() const {
                return Signal{SignalNr{m_raw.si_signo}};
        }
        Signal sigNr() const  {…}
 
 
        Source source() const;
 
 
        bool isTrustedSource() const {
                return m_raw.si_code >= 0;
        }
        bool isTrustedSource() const  {…}
 
        bool isFaultSignal() const;
 
        std::optional<const UserSigData> userSigData() const;
 
        std::optional<const QueueSigData> queueSigData() const;
 
        std::optional<const MsgQueueData> msgQueueData() const;
 
        std::optional<const TimerData> timerData() const;
 
 
        std::optional<const SysData> sysData() const;
 
 
        std::optional<const ChildData> childData() const;
 
 
        std::optional<const PollData> pollData() const;
 
 
        std::optional<const IllData> illData() const;
 
 
        std::optional<const FPEData> fpeData() const;
 
 
        std::optional<const SegfaultData> segfaultData() const;
 
 
        std::optional<const BusData> busData() const;
 
        void clear() {
                zero_object(m_raw);
        }
        void clear() {…}
 
        const siginfo_t* raw() const {
                return &m_raw;
        }
 
        siginfo_t* raw() {
                return &m_raw;
        }
 
protected: // functions
 
 
        Errno error() const {
                return Errno{m_raw.si_errno};
        }
        Errno error() const  {…}
 
        ProcessCtx procCtx() const {
                return ProcessCtx{pid(), uid()};
        }
 
        ProcessID pid() const {
                return ProcessID{m_raw.si_pid};
        }
 
        UserID uid() const {
                return UserID{m_raw.si_uid};
        }
 
protected: // data
 
        siginfo_t m_raw;
};
class COSMOS_API SigInfo {…};
 
} // end ns