Ladybird/Qt: Add Qt implementation of register/unregister_signal

Author: https://github.com/ADKaster
Commit: https://github.com/LadybirdBrowser/ladybird/commit/53f9e68799
Pull-request: https://github.com/LadybirdBrowser/ladybird/pull/319

Ladybird/Qt/EventLoopImplementationQt.cpp

@@ -7,9 +7,12 @@
 #include "EventLoopImplementationQt.h"
 #include "EventLoopImplementationQtEventTarget.h"
 #include <AK/IDAllocator.h>
+#include <AK/Singleton.h>
+#include <AK/TemporaryChange.h>
 #include <LibCore/Event.h>
 #include <LibCore/EventReceiver.h>
 #include <LibCore/Notifier.h>
+#include <LibCore/System.h>
 #include <LibCore/ThreadEventQueue.h>
 #include <QCoreApplication>
 #include <QTimer>
@@ -32,6 +35,134 @@ struct ThreadData {
     HashMap<Core::Notifier*, NonnullOwnPtr<QSocketNotifier>> notifiers;
 };
 
+class SignalHandlers : public RefCounted<SignalHandlers> {
+    AK_MAKE_NONCOPYABLE(SignalHandlers);
+    AK_MAKE_NONMOVABLE(SignalHandlers);
+
+public:
+    SignalHandlers(int signal_number, void (*handle_signal)(int));
+    ~SignalHandlers();
+
+    void dispatch();
+    int add(Function<void(int)>&& handler);
+    bool remove(int handler_id);
+
+    bool is_empty() const
+    {
+        if (m_calling_handlers) {
+            for (auto const& handler : m_handlers_pending) {
+                if (handler.value)
+                    return false; // an add is pending
+            }
+        }
+        return m_handlers.is_empty();
+    }
+
+    bool have(int handler_id) const
+    {
+        if (m_calling_handlers) {
+            auto it = m_handlers_pending.find(handler_id);
+            if (it != m_handlers_pending.end()) {
+                if (!it->value)
+                    return false; // a deletion is pending
+            }
+        }
+        return m_handlers.contains(handler_id);
+    }
+
+    int m_signal_number;
+    void (*m_original_handler)(int);
+    HashMap<int, Function<void(int)>> m_handlers;
+    HashMap<int, Function<void(int)>> m_handlers_pending;
+    bool m_calling_handlers { false };
+};
+
+SignalHandlers::SignalHandlers(int signal_number, void (*handle_signal)(int))
+    : m_signal_number(signal_number)
+    , m_original_handler(signal(signal_number, handle_signal))
+{
+}
+
+SignalHandlers::~SignalHandlers()
+{
+    (void)::signal(m_signal_number, m_original_handler);
+}
+
+struct SignalHandlersInfo {
+    HashMap<int, NonnullRefPtr<SignalHandlers>> signal_handlers;
+    int next_signal_id { 0 };
+};
+
+static Singleton<SignalHandlersInfo> s_signals;
+SignalHandlersInfo* signals_info()
+{
+    return s_signals.ptr();
+}
+
+void SignalHandlers::dispatch()
+{
+    TemporaryChange change(m_calling_handlers, true);
+    for (auto& handler : m_handlers)
+        handler.value(m_signal_number);
+    if (!m_handlers_pending.is_empty()) {
+        // Apply pending adds/removes
+        for (auto& handler : m_handlers_pending) {
+            if (handler.value) {
+                auto result = m_handlers.set(handler.key, move(handler.value));
+                VERIFY(result == AK::HashSetResult::InsertedNewEntry);
+            } else {
+                m_handlers.remove(handler.key);
+            }
+        }
+        m_handlers_pending.clear();
+    }
+}
+
+int SignalHandlers::add(Function<void(int)>&& handler)
+{
+    int id = ++signals_info()->next_signal_id; // TODO: worry about wrapping and duplicates?
+    if (m_calling_handlers)
+        m_handlers_pending.set(id, move(handler));
+    else
+        m_handlers.set(id, move(handler));
+    return id;
+}
+
+bool SignalHandlers::remove(int handler_id)
+{
+    VERIFY(handler_id != 0);
+    if (m_calling_handlers) {
+        auto it = m_handlers.find(handler_id);
+        if (it != m_handlers.end()) {
+            // Mark pending remove
+            m_handlers_pending.set(handler_id, {});
+            return true;
+        }
+        it = m_handlers_pending.find(handler_id);
+        if (it != m_handlers_pending.end()) {
+            if (!it->value)
+                return false; // already was marked as deleted
+            it->value = nullptr;
+            return true;
+        }
+        return false;
+    }
+    return m_handlers.remove(handler_id);
+}
+
+static void dispatch_signal(int signal_number)
+{
+    auto& info = *signals_info();
+    auto handlers = info.signal_handlers.find(signal_number);
+    if (handlers != info.signal_handlers.end()) {
+        // Make sure we bump the ref count while dispatching the handlers!
+        // This allows a handler to unregister/register while the handlers
+        // are being called!
+        auto handler = handlers->value;
+        handler->dispatch();
+    }
+}
+
 EventLoopImplementationQt::EventLoopImplementationQt()
 {
 }
@@ -143,6 +274,46 @@ void EventLoopManagerQt::unregister_notifier(Core::Notifier& notifier)
     ThreadData::the().notifiers.remove(&notifier);
 }
 
+void EventLoopManagerQt::handle_signal(int signal_number)
+{
+    auto& that = static_cast<EventLoopManagerQt&>(Core::EventLoopManager::the());
+    // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66425
+    // Apparently warn_unused_result ignoring (void) casts is a feature
+    [[maybe_unused]] auto _ = ::write(that.m_signal_socket_fds[1], &signal_number, sizeof(signal_number));
+}
+
+int EventLoopManagerQt::register_signal(int signal_number, Function<void(int)> handler)
+{
+    VERIFY(signal_number != 0);
+    auto& info = *signals_info();
+    auto handlers = info.signal_handlers.find(signal_number);
+    if (handlers == info.signal_handlers.end()) {
+        auto signal_handlers = adopt_ref(*new SignalHandlers(signal_number, EventLoopManagerQt::handle_signal));
+        auto handler_id = signal_handlers->add(move(handler));
+        info.signal_handlers.set(signal_number, move(signal_handlers));
+        return handler_id;
+    } else {
+        return handlers->value->add(move(handler));
+    }
+}
+
+void EventLoopManagerQt::unregister_signal(int handler_id)
+{
+    VERIFY(handler_id != 0);
+    int remove_signal_number = 0;
+    auto& info = *signals_info();
+    for (auto& h : info.signal_handlers) {
+        auto& handlers = *h.value;
+        if (handlers.remove(handler_id)) {
+            if (handlers.is_empty())
+                remove_signal_number = handlers.m_signal_number;
+            break;
+        }
+    }
+    if (remove_signal_number != 0)
+        info.signal_handlers.remove(remove_signal_number);
+}
+
 void EventLoopManagerQt::did_post_event()
 {
     QCoreApplication::postEvent(m_main_thread_event_target.ptr(), new QtEventLoopManagerEvent(QtEventLoopManagerEvent::process_event_queue_event_type()));
@@ -160,9 +331,29 @@ bool EventLoopManagerQt::event_target_received_event(Badge<EventLoopImplementati
 EventLoopManagerQt::EventLoopManagerQt()
     : m_main_thread_event_target(make<EventLoopImplementationQtEventTarget>())
 {
+    MUST(Core::System::socketpair(AF_LOCAL, SOCK_STREAM, 0, m_signal_socket_fds));
+    m_signal_socket_notifier = new QSocketNotifier(m_signal_socket_fds[0], QSocketNotifier::Read);
+    QObject::connect(m_signal_socket_notifier, &QSocketNotifier::activated, [this] {
+        int signal_number = {};
+        ssize_t nread;
+        do {
+            errno = 0;
+            nread = read(this->m_signal_socket_fds[0], &signal_number, sizeof(signal_number));
+            if (nread >= 0)
+                break;
+        } while (errno == EINTR);
+        VERIFY(nread == sizeof(signal_number));
+        dispatch_signal(signal_number);
+    });
+    m_signal_socket_notifier->setEnabled(true);
 }
 
-EventLoopManagerQt::~EventLoopManagerQt() = default;
+EventLoopManagerQt::~EventLoopManagerQt()
+{
+    delete m_signal_socket_notifier;
+    ::close(m_signal_socket_fds[0]);
+    ::close(m_signal_socket_fds[1]);
+}
 
 NonnullOwnPtr<Core::EventLoopImplementation> EventLoopManagerQt::make_implementation()
 {

Ladybird/Qt/EventLoopImplementationQt.h

@@ -35,12 +35,15 @@ public:
     virtual void did_post_event() override;
     static bool event_target_received_event(Badge<EventLoopImplementationQtEventTarget>, QEvent* event);
 
-    // FIXME: These APIs only exist for obscure use-cases inside SerenityOS. Try to get rid of them.
-    virtual int register_signal(int, Function<void(int)>) override { return 0; }
-    virtual void unregister_signal(int) override { }
+    virtual int register_signal(int, Function<void(int)>) override;
+    virtual void unregister_signal(int) override;
 
 private:
+    static void handle_signal(int);
+
     NonnullOwnPtr<EventLoopImplementationQtEventTarget> m_main_thread_event_target;
+    QSocketNotifier* m_signal_socket_notifier { nullptr };
+    int m_signal_socket_fds[2] = { -1, -1 };
 };
 
 class QtEventLoopManagerEvent final : public QEvent {