signal.hxx

Go to the documentation of this file.

#pragma once
 
// C++
#include <variant>
 
// cosmos
#include <cosmos/BitMask.hxx>
#include <cosmos/memory.hxx>
#include <cosmos/proc/PidFD.hxx>
#include <cosmos/proc/types.hxx>
#include <cosmos/thread/thread.hxx>
#include <cosmos/time/types.hxx>
#include <cosmos/utils.hxx>
 
namespace cosmos {
        class SigSet;
        class SigInfo;
        class SigAction;
}
 
namespace cosmos::signal {
 
/* constants for all well known signal numbers */
 
constexpr Signal NONE          = Signal{SignalNr::NONE};
constexpr Signal HANGUP        = Signal{SignalNr::HANGUP};
constexpr Signal INTERRUPT     = Signal{SignalNr::INTERRUPT};
constexpr Signal QUIT          = Signal{SignalNr::QUIT};
constexpr Signal ILL           = Signal{SignalNr::ILL};
constexpr Signal TRAP          = Signal{SignalNr::TRAP};
constexpr Signal SYS_TRAP      = Signal{SignalNr::SYS_TRAP};
constexpr Signal ABORT         = Signal{SignalNr::ABORT};
constexpr Signal IOT           = Signal{SignalNr::IOT};
constexpr Signal BUS           = Signal{SignalNr::BUS};
constexpr Signal FPE           = Signal{SignalNr::FPE};
constexpr Signal KILL          = Signal{SignalNr::KILL};
constexpr Signal USR1          = Signal{SignalNr::USR1};
constexpr Signal SEGV          = Signal{SignalNr::SEGV};
constexpr Signal USR2          = Signal{SignalNr::USR2};
constexpr Signal PIPE          = Signal{SignalNr::PIPE};
constexpr Signal ALARM         = Signal{SignalNr::ALARM};
constexpr Signal TERMINATE     = Signal{SignalNr::TERMINATE};
constexpr Signal STACK_FAULT   = Signal{SignalNr::STACK_FAULT};
constexpr Signal CHILD         = Signal{SignalNr::CHILD};
constexpr Signal CONT          = Signal{SignalNr::CONT};
constexpr Signal STOP          = Signal{SignalNr::STOP};
constexpr Signal TERM_STOP     = Signal{SignalNr::TERM_STOP};
constexpr Signal TERM_INPUT    = Signal{SignalNr::TERM_INPUT};
constexpr Signal TERM_OUTPUT   = Signal{SignalNr::TERM_OUTPUT};
constexpr Signal URGENT        = Signal{SignalNr::URGENT};
constexpr Signal CPU_EXCEEDED  = Signal{SignalNr::CPU_EXCEEDED};
constexpr Signal FS_EXCEEDED   = Signal{SignalNr::FS_EXCEEDED};
constexpr Signal VIRTUAL_ALARM = Signal{SignalNr::VIRTUAL_ALARM};
constexpr Signal PROFILING     = Signal{SignalNr::PROFILING};
constexpr Signal WIN_CHANGED   = Signal{SignalNr::WIN_CHANGED};
constexpr Signal IO_EVENT      = Signal{SignalNr::IO_EVENT};
constexpr Signal POLL          = Signal{SignalNr::POLL};
constexpr Signal POWER         = Signal{SignalNr::POWER};
constexpr Signal BAD_SYS       = Signal{SignalNr::BAD_SYS};
constexpr Signal MAXIMUM       = Signal{SignalNr::MAXIMUM};
 
 
inline Signal rt_min() {
        return Signal{SignalNr{SIGRTMIN}};
}
 
inline Signal rt_max() {
        return Signal{SignalNr{SIGRTMAX}};
}
 
inline size_t num_rt_sigs() {
        return to_integral(rt_max().raw()) - to_integral(rt_min().raw());
}
 
 
COSMOS_API void raise(const Signal s);
 
 
COSMOS_API void send(const ProcessID proc, const Signal s);
 
 
COSMOS_API void send(const ProcessID proc, const Signal s, std::variant<void*, int> data);
 
 
COSMOS_API void send(const PidFD pidfd, const Signal s);
 
 
COSMOS_API void send(const ProcessID proc, const ThreadID thread, const Signal s);
 
 
COSMOS_API void pause();
 
 
COSMOS_API void suspend(const SigSet &mask);
 
 
COSMOS_API Signal wait(const SigSet &set);
 
 
COSMOS_API void wait_info(const SigSet &set, SigInfo &info);
 
enum class WaitRes {
        SIGNALED, 
        NO_RESULT 
};
 
 
COSMOS_API WaitRes timed_wait(const SigSet &set, SigInfo &info, const IntervalTime timeout);
 
 
inline WaitRes poll_info(const SigSet &set, SigInfo &info) {
        return timed_wait(set, info, IntervalTime{0});
}
 
 
COSMOS_API void set_action(const Signal sig, const SigAction &action, SigAction *old = nullptr);
 
 
COSMOS_API void get_action(const Signal sig, SigAction &action);
 
 
COSMOS_API void block(const SigSet &s, SigSet *old = nullptr);
 
COSMOS_API void unblock(const SigSet &s, SigSet *old = nullptr);
 
COSMOS_API void set_sigmask(const SigSet &s, SigSet *old = nullptr);
 
COSMOS_API void get_sigmask(SigSet &old);
 
inline void restore(const Signal sig) {
        ::signal(to_integral(sig.raw()), SIG_DFL);
}
 
 
inline void ignore(const Signal sig) {
        ::signal(to_integral(sig.raw()), SIG_IGN);
}
 
class COSMOS_API Stack {
public: // types
 
        enum class Flag : int {
                ON_STACK    = SS_ONSTACK, 
                DISABLE     = SS_DISABLE, 
                /* SS_AUTODISARM not yet in userspace headers? */
                AUTO_DISARM = 1 << 31,    
        };
 
        using Flags = BitMask<Flag>;
 
        static size_t MIN_SIZE;
 
public: // functions
 
        Stack() {
                clear();
        }
 
        Stack (const no_init_t) {}
 
        void setFlags(const Flags flags) {
                m_raw.ss_flags = flags.raw();
        }
 
        Flags getFlags() const {
                return Flags{m_raw.ss_flags};
        }
 
        void setBase(void *base) {
                m_raw.ss_sp = base;
        }
 
        void* getBase() const {
                return m_raw.ss_sp;
        }
 
        void setSize(const size_t size) {
                m_raw.ss_size = size;
        }
 
        size_t getSize() const {
                return m_raw.ss_size;
        }
 
        void clear() {
                zero_object(m_raw);
        }
 
        auto raw() {
                return &m_raw;
        }
 
        auto raw() const {
                return &m_raw;
        }
 
protected: // data
 
        stack_t m_raw;
};
 
 
COSMOS_API void set_altstack(const Stack &stack, Stack *old = nullptr);
 
 
COSMOS_API void get_altstack(Stack &old);
 
} // end ns