#include <variant>
#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>

Classes
class	cosmos::signal::Stack
	Data structure used for defining an alternate signal stack. More...

Enumerations
enum class	cosmos::signal::WaitRes { SIGNALED , NO_RESULT }
	Strong type to express timed_wait() and poll_info() results. More...

Functions
Signal	cosmos::signal::rt_min ()
	Returns the first real-time signal available.

Signal	cosmos::signal::rt_max ()
	Returns the last real-time signal available.

size_t	cosmos::signal::num_rt_sigs ()
	Returns the number of available real-time signals.

void	cosmos::signal::raise (const Signal s)
	Sends a signal to the caller itself.

void	cosmos::signal::send (const ProcessID proc, const Signal s)
	Sends a signal to another process based on process ID (kill).

void	cosmos::signal::send (const ProcessID proc, const Signal s, std::variant< void *, int > data)
	Sends a signal including data (`sigqueue()`).

void	cosmos::signal::send (const PidFD pidfd, const Signal s)
	Sends a signal to another process based on a pidfd.

void	cosmos::signal::send (const ProcessID proc, const ThreadID thread, const Signal s)
	Sends a signal to a specific thread of a process.

void	cosmos::signal::pause ()
	Suspend execution of the calling thread until an asynchronous signal occurs.

void	cosmos::signal::suspend (const SigSet &mask)
	Suspend execution with altered signal mask until an asynchronous signal occurs.

Signal	cosmos::signal::wait (const SigSet &set)
	Wait for a signal from `set` to occur.

void	cosmos::signal::wait_info (const SigSet &set, SigInfo &info)
	Wait for a signal from `set` to occur and fill in `info` with signal details.

WaitRes	cosmos::signal::timed_wait (const SigSet &set, SigInfo &info, const IntervalTime timeout)
	Variant of wait_info() with a timeout.

WaitRes	cosmos::signal::poll_info (const SigSet &set, SigInfo &info)
	Check for a pending signal from `set` and fill in `info` with signal details.

void	cosmos::signal::set_action (const Signal sig, const SigAction &action, SigAction *old=nullptr)
	Configure asynchronous signal delivery behaviour.

void	cosmos::signal::get_action (const Signal sig, SigAction &action)
	Gets the currently installed SigAction configuration for `sig`.

void	cosmos::signal::block (const SigSet &s, SigSet *old=nullptr)
	Blocks the given set of signals in the caller's signal mask.

void	cosmos::signal::unblock (const SigSet &s, SigSet *old=nullptr)
	Unblocks the given set of signals in the caller's signal mask.

void	cosmos::signal::set_sigmask (const SigSet &s, SigSet *old=nullptr)
	Completely replace the caller's signal mask by the given set of blocked signals.

void	cosmos::signal::get_sigmask (SigSet &old)
	Returns the currently active signal mask for the calling thread.

void	cosmos::signal::restore (const Signal sig)
	Restores the default signal handling behaviour for the given signal.

void	cosmos::signal::ignore (const Signal sig)
	Ignore signal delivery for the given signal.

void	cosmos::signal::set_altstack (const Stack &stack, Stack *old=nullptr)
	Configure an alternate signal stack.

void	cosmos::signal::get_altstack (Stack &old)
	Retrieve the current alternate signal stack configuration.

Variables
constexpr Signal	cosmos::signal::NONE = Signal{SignalNr::NONE}

constexpr Signal	cosmos::signal::HANGUP = Signal{SignalNr::HANGUP}

constexpr Signal	cosmos::signal::INTERRUPT = Signal{SignalNr::INTERRUPT}

constexpr Signal	cosmos::signal::QUIT = Signal{SignalNr::QUIT}

constexpr Signal	cosmos::signal::ILL = Signal{SignalNr::ILL}

constexpr Signal	cosmos::signal::TRAP = Signal{SignalNr::TRAP}

constexpr Signal	cosmos::signal::SYS_TRAP = Signal{SignalNr::SYS_TRAP}

constexpr Signal	cosmos::signal::ABORT = Signal{SignalNr::ABORT}

constexpr Signal	cosmos::signal::IOT = Signal{SignalNr::IOT}

constexpr Signal	cosmos::signal::BUS = Signal{SignalNr::BUS}

constexpr Signal	cosmos::signal::FPE = Signal{SignalNr::FPE}

constexpr Signal	cosmos::signal::KILL = Signal{SignalNr::KILL}

constexpr Signal	cosmos::signal::USR1 = Signal{SignalNr::USR1}

constexpr Signal	cosmos::signal::SEGV = Signal{SignalNr::SEGV}

constexpr Signal	cosmos::signal::USR2 = Signal{SignalNr::USR2}

constexpr Signal	cosmos::signal::PIPE = Signal{SignalNr::PIPE}

constexpr Signal	cosmos::signal::ALARM = Signal{SignalNr::ALARM}

constexpr Signal	cosmos::signal::TERMINATE = Signal{SignalNr::TERMINATE}

constexpr Signal	cosmos::signal::STACK_FAULT = Signal{SignalNr::STACK_FAULT}

constexpr Signal	cosmos::signal::CHILD = Signal{SignalNr::CHILD}

constexpr Signal	cosmos::signal::CONT = Signal{SignalNr::CONT}

constexpr Signal	cosmos::signal::STOP = Signal{SignalNr::STOP}

constexpr Signal	cosmos::signal::TERM_STOP = Signal{SignalNr::TERM_STOP}

constexpr Signal	cosmos::signal::TERM_INPUT = Signal{SignalNr::TERM_INPUT}

constexpr Signal	cosmos::signal::TERM_OUTPUT = Signal{SignalNr::TERM_OUTPUT}

constexpr Signal	cosmos::signal::URGENT = Signal{SignalNr::URGENT}

constexpr Signal	cosmos::signal::CPU_EXCEEDED = Signal{SignalNr::CPU_EXCEEDED}

constexpr Signal	cosmos::signal::FS_EXCEEDED = Signal{SignalNr::FS_EXCEEDED}

constexpr Signal	cosmos::signal::VIRTUAL_ALARM = Signal{SignalNr::VIRTUAL_ALARM}

constexpr Signal	cosmos::signal::PROFILING = Signal{SignalNr::PROFILING}

constexpr Signal	cosmos::signal::WIN_CHANGED = Signal{SignalNr::WIN_CHANGED}

constexpr Signal	cosmos::signal::IO_EVENT = Signal{SignalNr::IO_EVENT}

constexpr Signal	cosmos::signal::POLL = Signal{SignalNr::POLL}

constexpr Signal	cosmos::signal::POWER = Signal{SignalNr::POWER}

constexpr Signal	cosmos::signal::BAD_SYS = Signal{SignalNr::BAD_SYS}

constexpr Signal	cosmos::signal::MAXIMUM = Signal{SignalNr::MAXIMUM}

Detailed Description

Constants and functions for process signal handling.

Definition in file signal.hxx.

Enumeration Type Documentation

◆ WaitRes

enum class cosmos::signal::WaitRes

strong

Strong type to express timed_wait() and poll_info() results.

Enumerator
SIGNALED	a signal has been caught.
NO_RESULT	no signal was caught / timeout occurred.

Definition at line 179 of file signal.hxx.

                   {
        SIGNALED, 
        NO_RESULT 
};

Function Documentation

◆ block()

COSMOS_API void cosmos::signal::block	(	const SigSet &	s,
		SigSet *	old = nullptr )

Blocks the given set of signals in the caller's signal mask.

Blocked signals won't be delivered asynchronously to the process i.e. no asynchronous signal handler will be invoked, the default action will not be perfomed (except for signal where it cannot be suppressed). Also the default action will not be executed. This allows to collect the information synchronously e.g. by using a SignalFD.

If old is provided then the previous signal mask is returned into this SigSet object.

Definition at line 154 of file signal.cxx.

                                         {
        set_signal_mask(SIG_BLOCK, s.raw(), old ? old->raw() : nullptr);
}

◆ get_action()

COSMOS_API void cosmos::signal::get_action	(	const Signal	sig,
		SigAction &	action )

Gets the currently installed SigAction configuration for sig.

This can be used to explicitly store the current SigAction configuration for a signal for the purposes of restoring it at a later point in time via set_action().

On error an ApiError is thrown. The following errors are documented for this call:

Errno::FAULT: action does not have a valid address.
Errno::INVALID_ARG: sig is not a valid signal number.

Definition at line 113 of file SigAction.cxx.

                                                     {
 
        const auto raw_sig = to_integral(sig.raw());
 
        if (::sigaction(raw_sig, nullptr, action.raw())) {
                cosmos_throw (ApiError("sigaction()"));
        }
 
        action.updateFromOld(
                reinterpret_cast<SigAction::InfoHandler>(info_handlers[raw_sig].load()),
                reinterpret_cast<SigAction::SimpleHandler>(simple_handlers[raw_sig].load())
        );
}

◆ get_altstack()

COSMOS_API void cosmos::signal::get_altstack ( Stack & old )

Retrieve the current alternate signal stack configuration.

On error an ApiError is thrown. Errno::INVALID_ARG is documented for the case when old is outside of the process's address space.

Definition at line 179 of file signal.cxx.

                              {
        if (::sigaltstack(nullptr, old.raw()) != 0) {
                cosmos_throw (ApiError("sigalstack()"));
        }
}

◆ get_sigmask()

COSMOS_API void cosmos::signal::get_sigmask ( SigSet & old )

Returns the currently active signal mask for the calling thread.

Definition at line 166 of file signal.cxx.

                              {
        // `how` is ignored when no `set` is provided. Just return the current mask in `old`.
        set_signal_mask(0, nullptr, old.raw());
}

◆ ignore()

void cosmos::signal::ignore ( const Signal sig )

inline

Ignore signal delivery for the given signal.

Ignoring a signal can make sense for the Signal::CHILD signal, in which case child processes will not become zombies, even if the parent does not wait on them.

See also: proc::wait().

Definition at line 309 of file signal.hxx.

                                     {
        ::signal(to_integral(sig.raw()), SIG_IGN);
}

◆ num_rt_sigs()

size_t cosmos::signal::num_rt_sigs ( )

inline

Returns the number of available real-time signals.

Definition at line 85 of file signal.hxx.

                            {
        return to_integral(rt_max().raw()) - to_integral(rt_min().raw());
}

◆ pause()

COSMOS_API void cosmos::signal::pause ( )

Suspend execution of the calling thread until an asynchronous signal occurs.

The calling thread will be blocked until a signal is delivered that either terminates the process or causes the execution of an asynchronous signal catching function (e.g. registered via cosmos::signal::set_action())..

Definition at line 113 of file signal.cxx.

             {
        // this call always returns -1 with errno set to EINT
        ::pause();
}

◆ poll_info()

WaitRes cosmos::signal::poll_info	(	const SigSet &	set,
		SigInfo &	info )

inline

Check for a pending signal from set and fill in info with signal details.

This is a polling variant of wait_info() that will not block. If no signal is pending then WaitRes::NO_RESULT is returned and info is left unchanged. Otherwise WaitRes::SIGNALED is returned and info is filled accordingly.

The same errors as in timed_wait() can occur here.

Definition at line 208 of file signal.hxx.

                                                           {
        return timed_wait(set, info, IntervalTime{0});
}

◆ raise()

COSMOS_API void cosmos::signal::raise ( const Signal s )

Sends a signal to the caller itself.

The given signal will be delivered to the calling process or thread itself.

Exceptions

Throws an ApiError on error.

Definition at line 34 of file signal.cxx.

                           {
        if (::raise(to_integral(s.raw()))) {
                cosmos_throw (ApiError("raise()"));
        }
}

◆ restore()

void cosmos::signal::restore ( const Signal sig )

inline

Restores the default signal handling behaviour for the given signal.

Definition at line 299 of file signal.hxx.

                                      {
        ::signal(to_integral(sig.raw()), SIG_DFL);
}

◆ rt_max()

Signal cosmos::signal::rt_max ( )

inline

Returns the last real-time signal available.

Definition at line 80 of file signal.hxx.

                       {
        return Signal{SignalNr{SIGRTMAX}};
}

◆ rt_min()

Signal cosmos::signal::rt_min ( )

inline

Returns the first real-time signal available.

Real-time signals are a dynamic range of signals beyond the classic predefined signals described in SignalNr. They have the special property that they are queued i.e. multiple signals can accumulate for the same signal number and each occurrence will be delivered to the process.

Definition at line 75 of file signal.hxx.

                       {
        return Signal{SignalNr{SIGRTMIN}};
}

◆ send() [1/4]

COSMOS_API void cosmos::signal::send	(	const PidFD	pidfd,
		const Signal	s )

Sends a signal to another process based on a pidfd.

Parameters

[in] pidfd needs to refer to a valid PidFD type file descriptor. The process represented by it will be sent the specified signal s.

Exceptions

Throws an ApiError on error.

Definition at line 65 of file signal.cxx.

                                             {
        if (!running_on_valgrind) {
                // there's no glibc wrapper for this yet
                //
                // the third siginfo_t argument allows more precise control of the
                // signal auxiliary data, but the defaults are just like kill(), so
                // let's use them for now.
                if (::pidfd_send_signal(to_integral(pidfd.raw()), to_integral(s.raw()), nullptr, 0) != 0) {
                        cosmos_throw (ApiError("pidfd_send_signal()"));
                }
        } else {
                // when running on Valgrind then this system isn't covered yet
                // by Valgrind's virtual machine. Implement a fallback to
                // emulate the system call behaviour.
                //
                // we can find out the PID the FD is for by inspect proc
                std::string path{"/proc/self/fdinfo/"};
                path += std::to_string(to_integral(pidfd.raw()));
                std::ifstream fdinfo;
                fdinfo.open(path);
 
                if (!fdinfo) {
                        cosmos_throw (ApiError("open(\"/proc/self/fdinfo/<pidfd>\")"));
                }
 
                std::string line;
                constexpr std::string_view PID_FIELD{"Pid:"};
 
                while (std::getline(fdinfo, line).good()) {
                        if (!is_prefix(line, PID_FIELD))
                                continue;
 
                        auto pid_str = stripped(line.substr(PID_FIELD.size()));
                        size_t processed = 0;
                        auto pid = std::stoi(pid_str, &processed);
 
                        if (processed < 1) {
                                cosmos_throw (RuntimeError("failed to determine PID for PIDFD (valgrind fallback logic)"));
                        }
 
                        signal::send(ProcessID{pid}, s);
                        return;
                }
 
                cosmos_throw (RuntimeError("couldn't parse PID for PIDFD (valgrind fallback logic)"));
        }
}

◆ send() [2/4]

COSMOS_API void cosmos::signal::send	(	const ProcessID	proc,
		const Signal	s )

Sends a signal to another process based on process ID (kill).

Exceptions

Throws an ApiError on error.

Definition at line 40 of file signal.cxx.

                                                {
        if (::kill(to_integral(proc), to_integral(s.raw()))) {
                cosmos_throw (ApiError("kill()"));
        }
}

◆ send() [3/4]

COSMOS_API void cosmos::signal::send	(	const ProcessID	proc,
		const Signal	s,
		std::variant< void *, int >	data )

Sends a signal including data (sigqueue()).

This is similar to send(ProcessID, Signal) but also attaches a data item to the signal to be sent. If the receiver uses extended APIs like an SA_SIGINFO signal handler then it can obtain the data from the si_value or si_int field of struct siginfo. The si_code field will be set to SI_QUEUE.

The data can either be an int or a void *, which can have different sizes on some architectures.

Definition at line 46 of file signal.cxx.

                                                                             {
        union sigval val{};
        if (std::holds_alternative<void*>(data)) {
                val.sival_ptr = std::get<void*>(data);
        } else if (std::holds_alternative<int>(data)) {
                val.sival_int = std::get<int>(data);
        }
 
        if (::sigqueue(to_integral(proc), to_integral(s.raw()), val)) {
                cosmos_throw (ApiError("sigqueue()"));
        }
}

◆ send() [4/4]

COSMOS_API void cosmos::signal::send	(	const ProcessID	proc,
		const ThreadID	thread,
		const Signal	s )

Sends a signal to a specific thread of a process.

Linux differentiates between process-directed and thread-directed signals. If a (multi-threaded) process is the target of a signal, then an arbitrary thread in that process will receive the signal. To target a specific thread this call can be used, which specifies a specific thread within a process.

Definition at line 59 of file signal.cxx.

                                                                       {
        if (::tgkill(to_integral(proc), to_integral(thread), to_integral(s.raw()))) {
                cosmos_throw (ApiError("tgkill()"));
        }
}

◆ set_action()

COSMOS_API void cosmos::signal::set_action	(	const Signal	sig,
		const SigAction &	action,
		SigAction *	old = nullptr )

Configure asynchronous signal delivery behaviour.

The asynchronous signal handling for sig will be configured according to the settings in action. Asynchronous signal handling should be avoided, if possible, for the following reasons:

the thread in whose context a signal is processed is undefined (unless thread-directed signals are used or careful settings for signal masks are maintained across all threads).
asynchronous signals can execute at any time, therefore the set of system calls and C library functions that may be executed from within a signal handler is extremely limited (see man 7 signal-safety). There is no protection against using unsafe functions in a signal handler, which can cause hard to find bugs.

There are some signals that can only be caught asynchronously. These are the fault family of signals like SIGSEGV, SIGFPE, SIGBUS and SIGILL. These are directed at the thread that triggers them and thus cannot be waited for in another thread.

If old is supplied then the previously installed signal handler configuration for sig is returned there e.g. for being able to restore it at a later point in time.

Libcosmos offers asynchronous signal handlers with type safe parameters (SigAction::SimpleHandler, SigAction::InfoHandler), but this comes at a cost. The sigaction() system call is very difficult to wrap. The extra level of indirection that libcosmos uses internally can cause additional types of race conditions. These race conditions can occur when an existing signal handling function is replaced by another. These race conditions make it impossible to determine if a signal that comes in while changing the signal handler is still based on the old signal handler configuration or already on the new one.

There should be very few use cases that actually require replacing one signal handler function by another. Typically a program installs signal handlers early on and never changes them again. If you do need to use different signal handlers for the same signal safely, though, then it is better to rely on synchronous signal handling (if possible) or employ direct sigaction() calls instead of using libcosmos for establishing them.

On error an ApiError is thrown. The following errors are documented for this call:

Errno::FAULT: action or old do not have valid addresses.
Errno::INVALID_ARG: sig is not a valid signal number.

Definition at line 66 of file SigAction.cxx.

                                                                           {
 
        const auto raw_sig = to_integral(sig.raw());
 
        if (::sigaction(raw_sig, action.raw(), old ? old->raw() : nullptr) != 0) {
                cosmos_throw (ApiError("sigaction()"));
        }
 
        /*
         * Here is a spot for a race condition, if previously a custom handler
         * was registered, then the new signal configuration can arrive at the
         * old handler until we rewrite the entries below.
         *
         * It is impossible to avoid that unless falling back to the plain C
         * callback. Locking is not possible, because the asynchronous handler
         * is not allowed to call locks (except for SYSV semaphores, which
         * would be overkill).
         */
 
        using SimpleHandler = SigAction::SimpleHandler;
        using InfoHandler = SigAction::InfoHandler;
 
        const auto &variant = action.m_handler;
        SimpleHandler old_simple = reinterpret_cast<SimpleHandler>(simple_handlers[raw_sig].load());
        InfoHandler old_info = reinterpret_cast<InfoHandler>(info_handlers[raw_sig].load());;
 
        if (std::holds_alternative<SimpleHandler>(variant)) {
                const auto handler = std::get<SimpleHandler>(variant);
 
                if (in_list(handler, {SigAction::IGNORE, SigAction::DEFAULT, SigAction::UNKNOWN})) {
                        // reset callback pointers just to be sure
                        simple_handlers[raw_sig].store(0);
                        info_handlers[raw_sig].store(0);
                } else {
                        const auto intptr = reinterpret_cast<intptr_t>(handler);
                        simple_handlers[raw_sig].store(intptr);
                }
        } else if (std::holds_alternative<InfoHandler>(variant)) {
                const auto intptr = reinterpret_cast<intptr_t>(std::get<InfoHandler>(variant));
                info_handlers[raw_sig].store(intptr);
        }
 
        if (old) {
                old->updateFromOld(old_info, old_simple);
        }
}

◆ set_altstack()

COSMOS_API void cosmos::signal::set_altstack	(	const Stack &	stack,
		Stack *	old = nullptr )

Configure an alternate signal stack.

This call informs the kernel of a memory area to be used for establishing the stack of asynchronous signal handlers. After configuring the alternate stack it can be used by establishing an asynchronous signal handler via cosmos::signal::set_action() with SigAction::Flag::ON_STACK set.

The previous alternate stack settings can optionally be returned in old. Only Flag::AUTO_DISARM will be recognized in stack. The other flags are only used in output data that can be returned in old.

On error an ApiError is thrown. The following error reasons are documented:

Errno::FAULT: stack or old are outside the process's address space.
Errno::INVALID_ARG: stack.getFlags() contains invalid flags.
Errno::NO_MEMORY: stack.getSize() is smaller than MIN_SIZE.
Errno::PERMISSION: Attempted to change the stack while it was active.

Definition at line 173 of file signal.cxx.

                                                  {
        if (::sigaltstack(stack.raw(), old ? old->raw() : nullptr) != 0) {
                cosmos_throw (ApiError("sigaltstack()"));
        }
}

◆ set_sigmask()

COSMOS_API void cosmos::signal::set_sigmask	(	const SigSet &	s,
		SigSet *	old )

Completely replace the caller's signal mask by the given set of blocked signals.

Definition at line 162 of file signal.cxx.

                                               {
        set_signal_mask(SIG_SETMASK, s.raw(), old ? old->raw() : nullptr);
}

◆ suspend()

COSMOS_API void cosmos::signal::suspend ( const SigSet & mask )

Suspend execution with altered signal mask until an asynchronous signal occurs.

This is similar to pause(), with the difference that the caller's signal mask is temporarily replaced by mask. Upon return from the function, the original signal mask will be restored.

Definition at line 118 of file signal.cxx.

                                 {
        // same as with pause() this call always returns -1 with errno set to EINT
        ::sigsuspend(mask.raw());
}

◆ timed_wait()

COSMOS_API WaitRes cosmos::signal::timed_wait	(	const SigSet &	set,
		SigInfo &	info,
		const IntervalTime	timeout )

Variant of wait_info() with a timeout.

This is just like wait_info() only with a timeout applied. If no signal from set arrives within timeout then info is left untouched and WaitRes::NO_RESULT is returned. Otherwise WaitRes::SIGNALED is returned and info is filled accordingly.

timeout is a relative time interval. There is no way to continue waiting for the remaining time should this call be interrupted.

On errors an ApiError is thrown. Errno::INTERRUPT and Errno::INVALID (bad timeout value) are the only documented errors.

Definition at line 141 of file signal.cxx.

                                                                                 {
        if (::sigtimedwait(set.raw(), info.raw(), &timeout) < 0) {
                switch(get_errno()) {
                        case Errno::AGAIN: return WaitRes::NO_RESULT;
                        default: {
                                cosmos_throw (ApiError("sigtimedwait()"));
                        }
                }
        }
 
        return WaitRes::SIGNALED;
}

◆ unblock()

COSMOS_API void cosmos::signal::unblock	(	const SigSet &	s,
		SigSet *	old )

Unblocks the given set of signals in the caller's signal mask.

Definition at line 158 of file signal.cxx.

                                           {
        set_signal_mask(SIG_UNBLOCK, s.raw(), old ? old->raw() : nullptr);
}

◆ wait()

COSMOS_API Signal cosmos::signal::wait ( const SigSet & set )

Wait for a signal from set to occur.

This call blocks execution until one of the signals found in set becomes pending for the calling thread. Once a signal is pending it will be removed from the pending list of signals and the call returns the number of the signal that occurred.

This method of waiting for signals does not provide any contextual information that may exist for the signal, only the signal number is provided.

On error an ApiError is thrown. Only Errno::INVALID is defined as a possible error reason, when an invalid signal is seen in set.

Definition at line 123 of file signal.cxx.

                               {
        int num{};
        const auto res = ::sigwait(set.raw(), &num);
 
        if (res != 0) {
                cosmos_throw (ApiError("sigwait()", Errno{res}));
        }
 
        return Signal{SignalNr{num}};
 
}

◆ wait_info()

COSMOS_API void cosmos::signal::wait_info	(	const SigSet &	set,
		SigInfo &	info )

Wait for a signal from set to occur and fill in info with signal details.

This is similar to wait(const SigSet&) but provides additional details about the signal that occurred in info.

On errors an ApiError is thrown. The only documented error condition is Errno::INTERRUPTED.

Definition at line 135 of file signal.cxx.

                                                 {
        if (::sigwaitinfo(set.raw(), info.raw()) < 0) {
                cosmos_throw (ApiError("sigwaitinfo()"));
        }
}

Variable Documentation

◆ ABORT

Signal cosmos::signal::ABORT = Signal{SignalNr::ABORT}

constexpr

Definition at line 38 of file signal.hxx.

38{SignalNr::ABORT};

◆ ALARM

Signal cosmos::signal::ALARM = Signal{SignalNr::ALARM}

constexpr

Definition at line 47 of file signal.hxx.

47{SignalNr::ALARM};

◆ BAD_SYS

Signal cosmos::signal::BAD_SYS = Signal{SignalNr::BAD_SYS}

constexpr

Definition at line 65 of file signal.hxx.

65{SignalNr::BAD_SYS};

◆ BUS

Signal cosmos::signal::BUS = Signal{SignalNr::BUS}

constexpr

Definition at line 40 of file signal.hxx.

40{SignalNr::BUS};

◆ CHILD

Signal cosmos::signal::CHILD = Signal{SignalNr::CHILD}

constexpr

Definition at line 50 of file signal.hxx.

50{SignalNr::CHILD};

◆ CONT

Signal cosmos::signal::CONT = Signal{SignalNr::CONT}

constexpr

Definition at line 51 of file signal.hxx.

51{SignalNr::CONT};

◆ CPU_EXCEEDED

Signal cosmos::signal::CPU_EXCEEDED = Signal{SignalNr::CPU_EXCEEDED}

constexpr

Definition at line 57 of file signal.hxx.

57{SignalNr::CPU_EXCEEDED};

◆ FPE

Signal cosmos::signal::FPE = Signal{SignalNr::FPE}

constexpr

Definition at line 41 of file signal.hxx.

41{SignalNr::FPE};

◆ FS_EXCEEDED

Signal cosmos::signal::FS_EXCEEDED = Signal{SignalNr::FS_EXCEEDED}

constexpr

Definition at line 58 of file signal.hxx.

58{SignalNr::FS_EXCEEDED};

◆ HANGUP

Signal cosmos::signal::HANGUP = Signal{SignalNr::HANGUP}

constexpr

Definition at line 32 of file signal.hxx.

32{SignalNr::HANGUP};

◆ ILL

Signal cosmos::signal::ILL = Signal{SignalNr::ILL}

constexpr

Definition at line 35 of file signal.hxx.

35{SignalNr::ILL};

◆ INTERRUPT

Signal cosmos::signal::INTERRUPT = Signal{SignalNr::INTERRUPT}

constexpr

Definition at line 33 of file signal.hxx.

33{SignalNr::INTERRUPT};

◆ IO_EVENT

Signal cosmos::signal::IO_EVENT = Signal{SignalNr::IO_EVENT}

constexpr

Definition at line 62 of file signal.hxx.

62{SignalNr::IO_EVENT};

◆ IOT

Signal cosmos::signal::IOT = Signal{SignalNr::IOT}

constexpr

Definition at line 39 of file signal.hxx.

39{SignalNr::IOT};

◆ KILL

Signal cosmos::signal::KILL = Signal{SignalNr::KILL}

constexpr

Definition at line 42 of file signal.hxx.

42{SignalNr::KILL};

◆ MAXIMUM

Signal cosmos::signal::MAXIMUM = Signal{SignalNr::MAXIMUM}

constexpr

Definition at line 66 of file signal.hxx.

66{SignalNr::MAXIMUM};

◆ NONE

Signal cosmos::signal::NONE = Signal{SignalNr::NONE}

constexpr

Definition at line 31 of file signal.hxx.

31{SignalNr::NONE};

◆ PIPE

Signal cosmos::signal::PIPE = Signal{SignalNr::PIPE}

constexpr

Definition at line 46 of file signal.hxx.

46{SignalNr::PIPE};

◆ POLL

Signal cosmos::signal::POLL = Signal{SignalNr::POLL}

constexpr

Definition at line 63 of file signal.hxx.

63{SignalNr::POLL};

◆ POWER

Signal cosmos::signal::POWER = Signal{SignalNr::POWER}

constexpr

Definition at line 64 of file signal.hxx.

64{SignalNr::POWER};

◆ PROFILING

Signal cosmos::signal::PROFILING = Signal{SignalNr::PROFILING}

constexpr

Definition at line 60 of file signal.hxx.

60{SignalNr::PROFILING};

◆ QUIT

Signal cosmos::signal::QUIT = Signal{SignalNr::QUIT}

constexpr

Definition at line 34 of file signal.hxx.

34{SignalNr::QUIT};

◆ SEGV

Signal cosmos::signal::SEGV = Signal{SignalNr::SEGV}

constexpr

Definition at line 44 of file signal.hxx.

44{SignalNr::SEGV};

◆ STACK_FAULT

Signal cosmos::signal::STACK_FAULT = Signal{SignalNr::STACK_FAULT}

constexpr

Definition at line 49 of file signal.hxx.

49{SignalNr::STACK_FAULT};

◆ STOP

Signal cosmos::signal::STOP = Signal{SignalNr::STOP}

constexpr

Definition at line 52 of file signal.hxx.

52{SignalNr::STOP};

◆ SYS_TRAP

Signal cosmos::signal::SYS_TRAP = Signal{SignalNr::SYS_TRAP}

constexpr

Definition at line 37 of file signal.hxx.

37{SignalNr::SYS_TRAP};

◆ TERM_INPUT

Signal cosmos::signal::TERM_INPUT = Signal{SignalNr::TERM_INPUT}

constexpr

Definition at line 54 of file signal.hxx.

54{SignalNr::TERM_INPUT};

◆ TERM_OUTPUT

Signal cosmos::signal::TERM_OUTPUT = Signal{SignalNr::TERM_OUTPUT}

constexpr

Definition at line 55 of file signal.hxx.

55{SignalNr::TERM_OUTPUT};

◆ TERM_STOP

Signal cosmos::signal::TERM_STOP = Signal{SignalNr::TERM_STOP}

constexpr

Definition at line 53 of file signal.hxx.

53{SignalNr::TERM_STOP};

◆ TERMINATE

Signal cosmos::signal::TERMINATE = Signal{SignalNr::TERMINATE}

constexpr

Definition at line 48 of file signal.hxx.

48{SignalNr::TERMINATE};

◆ TRAP

Signal cosmos::signal::TRAP = Signal{SignalNr::TRAP}

constexpr

Definition at line 36 of file signal.hxx.

36{SignalNr::TRAP};

◆ URGENT

Signal cosmos::signal::URGENT = Signal{SignalNr::URGENT}

constexpr

Definition at line 56 of file signal.hxx.

56{SignalNr::URGENT};

◆ USR1

Signal cosmos::signal::USR1 = Signal{SignalNr::USR1}

constexpr

Definition at line 43 of file signal.hxx.

43{SignalNr::USR1};

◆ USR2

Signal cosmos::signal::USR2 = Signal{SignalNr::USR2}

constexpr

Definition at line 45 of file signal.hxx.

45{SignalNr::USR2};

◆ VIRTUAL_ALARM

Signal cosmos::signal::VIRTUAL_ALARM = Signal{SignalNr::VIRTUAL_ALARM}

constexpr

Definition at line 59 of file signal.hxx.

59{SignalNr::VIRTUAL_ALARM};

◆ WIN_CHANGED

Signal cosmos::signal::WIN_CHANGED = Signal{SignalNr::WIN_CHANGED}

constexpr

Definition at line 61 of file signal.hxx.

61{SignalNr::WIN_CHANGED};

Classes

Enumerations

Functions

Variables

Detailed Description

Enumeration Type Documentation

◆ WaitRes

Function Documentation

◆ block()

◆ get_action()

◆ get_altstack()

◆ get_sigmask()

◆ ignore()

◆ num_rt_sigs()

◆ pause()

◆ poll_info()

◆ raise()

◆ restore()

◆ rt_max()

◆ rt_min()

◆ send() [1/4]

◆ send() [2/4]

◆ send() [3/4]

◆ send() [4/4]

◆ set_action()

◆ set_altstack()

◆ set_sigmask()

◆ suspend()

◆ timed_wait()

◆ unblock()

◆ wait()

◆ wait_info()

Variable Documentation

◆ ABORT

◆ ALARM

◆ BAD_SYS

◆ BUS

◆ CHILD

◆ CONT

◆ CPU_EXCEEDED

◆ FPE

◆ FS_EXCEEDED

◆ HANGUP

◆ ILL

◆ INTERRUPT

◆ IO_EVENT

◆ IOT

◆ KILL

◆ MAXIMUM

◆ NONE

◆ PIPE

◆ POLL

◆ POWER

◆ PROFILING

◆ QUIT

◆ SEGV

◆ STACK_FAULT

◆ STOP

◆ SYS_TRAP

◆ TERM_INPUT

◆ TERM_OUTPUT

◆ TERM_STOP

◆ TERMINATE

◆ TRAP

◆ URGENT

◆ USR1

◆ USR2

◆ VIRTUAL_ALARM

◆ WIN_CHANGED