134 lines
4.2 KiB
C++
134 lines
4.2 KiB
C++
#include "SignalCatcher.h"
|
|
#include "SignalHandler.h"
|
|
|
|
#include <algorithm>
|
|
#include <stdexcept>
|
|
#include <vector>
|
|
#include <cpp-utils/assert/assert.h>
|
|
#include <cpp-utils/thread/LeftRight.h>
|
|
|
|
using std::make_unique;
|
|
using std::vector;
|
|
using std::pair;
|
|
|
|
namespace cpputils {
|
|
|
|
namespace {
|
|
|
|
void got_signal(int signal);
|
|
|
|
class SignalCatcherRegistry final {
|
|
public:
|
|
void add(int signal, details::SignalCatcherImpl* signal_occurred_flag) {
|
|
_catchers.write([&] (auto& catchers) {
|
|
catchers.emplace_back(signal, signal_occurred_flag);
|
|
});
|
|
}
|
|
|
|
void remove(details::SignalCatcherImpl* catcher) {
|
|
_catchers.write([&] (auto& catchers) {
|
|
auto found = std::find_if(catchers.rbegin(), catchers.rend(), [catcher] (const auto& entry) {return entry.second == catcher;});
|
|
ASSERT(found != catchers.rend(), "Signal handler not found");
|
|
catchers.erase(--found.base()); // decrement because it's a reverse iterator
|
|
});
|
|
}
|
|
|
|
~SignalCatcherRegistry() {
|
|
ASSERT(0 == _catchers.read([] (auto& catchers) {return catchers.size();}), "Leftover signal catchers that weren't destroyed");
|
|
}
|
|
|
|
details::SignalCatcherImpl* find(int signal) {
|
|
// this is called in a signal handler and must be mutex-free.
|
|
return _catchers.read([&](auto& catchers) {
|
|
auto found = std::find_if(catchers.rbegin(), catchers.rend(), [signal](const auto& entry) {return entry.first == signal; });
|
|
ASSERT(found != catchers.rend(), "Signal handler not found");
|
|
return found->second;
|
|
});
|
|
}
|
|
|
|
static SignalCatcherRegistry& singleton() {
|
|
static SignalCatcherRegistry _singleton;
|
|
return _singleton;
|
|
}
|
|
|
|
private:
|
|
SignalCatcherRegistry() = default;
|
|
|
|
// using LeftRight datastructure because we need mutex-free reads. Signal handlers can't use mutexes.
|
|
LeftRight<vector<pair<int, details::SignalCatcherImpl*>>> _catchers;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(SignalCatcherRegistry);
|
|
};
|
|
|
|
class SignalCatcherRegisterer final {
|
|
public:
|
|
SignalCatcherRegisterer(int signal, details::SignalCatcherImpl* catcher)
|
|
: _catcher(catcher) {
|
|
SignalCatcherRegistry::singleton().add(signal, _catcher);
|
|
}
|
|
|
|
~SignalCatcherRegisterer() {
|
|
SignalCatcherRegistry::singleton().remove(_catcher);
|
|
}
|
|
|
|
private:
|
|
details::SignalCatcherImpl* _catcher;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(SignalCatcherRegisterer);
|
|
};
|
|
|
|
}
|
|
|
|
namespace details {
|
|
|
|
class SignalCatcherImpl final {
|
|
public:
|
|
SignalCatcherImpl(int signal, std::atomic<bool>* signal_occurred_flag)
|
|
: _signal_occurred_flag(signal_occurred_flag)
|
|
, _registerer(signal, this)
|
|
, _handler(signal) {
|
|
// note: the order of the members ensures that:
|
|
// - when registering the signal handler, the SignalCatcher impl already has a valid _signal_occurred_flag set.
|
|
// - when registering the signal handler fails, the _registerer will be destroyed again, unregistering this SignalCatcherImpl,
|
|
// i.e. there is no leak.
|
|
|
|
// Allow only the set of signals that is supported on all platforms, see for Windows: https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/signal?view=vs-2017
|
|
ASSERT(signal == SIGABRT || signal == SIGFPE || signal == SIGILL || signal == SIGINT || signal == SIGSEGV || signal == SIGTERM, "Unknown signal");
|
|
}
|
|
|
|
void setSignalOccurred() {
|
|
*_signal_occurred_flag = true;
|
|
}
|
|
private:
|
|
std::atomic<bool>* _signal_occurred_flag;
|
|
SignalCatcherRegisterer _registerer;
|
|
SignalHandlerRAII<&got_signal> _handler;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(SignalCatcherImpl);
|
|
};
|
|
|
|
}
|
|
|
|
namespace {
|
|
void got_signal(int signal) {
|
|
SignalCatcherRegistry::singleton().find(signal)->setSignalOccurred();
|
|
}
|
|
}
|
|
|
|
SignalCatcher::SignalCatcher(std::initializer_list<int> signals)
|
|
: _signal_occurred(false)
|
|
, _impls() {
|
|
// note: the order of the members ensures that:
|
|
// - when the signal handler is set, the _signal_occurred flag is already initialized.
|
|
// - the _signal_occurred flag will not be destructed as long as the signal handler might be called (i.e. as long as _impls lives)
|
|
|
|
_impls.reserve(signals.size());
|
|
for (int signal : signals) {
|
|
_impls.emplace_back(make_unique<details::SignalCatcherImpl>(signal, &_signal_occurred));
|
|
}
|
|
}
|
|
|
|
SignalCatcher::~SignalCatcher() {}
|
|
|
|
}
|