LibCore: Expose register_process and implement for Windows event loop

This is the closest Windows equivalent to integrating process exit
handlers into the event loop.

Linux could also integrate register_process() into the poll() based
Unix event loop via the SYS_pidfd_open syscall; however, macOS requires
a kqueue. So for now register_process will only be used by Windows to
implement WebView::ProcessMonitor.

Author: ayeteadoe

Libraries/LibCore/EventLoop.cpp

@@ -142,6 +142,16 @@ void EventLoop::unregister_notifier(Badge<Notifier>, Notifier& notifier)
     EventLoopManager::the().unregister_notifier(notifier);
 }
 
+void EventLoop::register_process(pid_t pid, ESCAPING Function<void(pid_t)> handler)
+{
+    EventLoopManager::the().register_process(pid, move(handler));
+}
+
+void EventLoop::unregister_process(pid_t pid)
+{
+    EventLoopManager::the().unregister_process(pid);
+}
+
 void EventLoop::wake()
 {
     m_impl->wake();

Libraries/LibCore/EventLoop.h

@@ -90,6 +90,10 @@ class EventLoop {
     static int register_signal(int signo, ESCAPING Function<void(int)> handler);
     static void unregister_signal(int handler_id);
 
+    // Invokes the specified handler when the process exits
+    static void register_process(pid_t pid, ESCAPING Function<void(pid_t)> handler);
+    static void unregister_process(pid_t pid);
+
     static bool is_running();
     static EventLoop& current();
 

Libraries/LibCore/EventLoopImplementation.h

@@ -35,6 +35,9 @@ class EventLoopManager {
     virtual int register_signal(int signal_number, Function<void(int)> handler) = 0;
     virtual void unregister_signal(int handler_id) = 0;
 
+    virtual void register_process(pid_t, ESCAPING Function<void(pid_t)>) { VERIFY_NOT_REACHED(); }
+    virtual void unregister_process(pid_t) { VERIFY_NOT_REACHED(); }
+
 protected:
     EventLoopManager();
 };

Libraries/LibCore/EventLoopImplementationWindows.cpp

@@ -66,6 +66,7 @@ enum class CompletionType : u8 {
     Wake,
     Timer,
     Notifer,
+    Process,
 };
 
 struct CompletionPacket {
@@ -101,6 +102,15 @@ struct EventLoopNotifier final : CompletionPacket {
     OwnHandle wait_event;
 };
 
+struct EventLoopProcess final : CompletionPacket {
+    ~EventLoopProcess() = default;
+
+    OwnHandle process;
+    pid_t pid;
+    Function<void(pid_t)> handler;
+    OwnHandle jobobject;
+};
+
 struct ThreadData {
     static ThreadData* the()
     {
@@ -136,6 +146,7 @@ struct ThreadData {
     // These are only used to register and unregister. The event loop doesn't access these.
     HashMap<intptr_t, NonnullOwnPtr<EventLoopTimer>> timers;
     HashMap<Notifier*, NonnullOwnPtr<EventLoopNotifier>> notifiers;
+    HashMap<pid_t, NonnullOwnPtr<EventLoopProcess>> processes;
 
     // The wake completion packet is posted to the thread's event loop to wake it.
     NonnullOwnPtr<EventLoopWake> wake_data;
@@ -210,6 +221,16 @@ size_t EventLoopImplementationWindows::pump(PumpMode pump_mode)
                 VERIFY(NT_SUCCESS(status));
                 continue;
             }
+            if (packet->type == CompletionType::Process) {
+                auto* process_data = static_cast<EventLoopProcess*>(packet);
+                pid_t const process_id = process_data->pid;
+                // NOTE: This may seem like the incorrect parameter, but https://learn.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-jobobject_associate_completion_port
+                // states that this field represents the event type indicator
+                DWORD const event_type = entry.dwNumberOfBytesTransferred;
+                if (reinterpret_cast<intptr_t>(entry.lpOverlapped) == process_id && (event_type == JOB_OBJECT_MSG_EXIT_PROCESS || event_type == JOB_OBJECT_MSG_ABNORMAL_EXIT_PROCESS))
+                    process_data->handler(process_id);
+                continue;
+            }
             VERIFY_NOT_REACHED();
         }
     } else {
@@ -358,6 +379,51 @@ void EventLoopManagerWindows::unregister_signal([[maybe_unused]] int handler_id)
     VERIFY_NOT_REACHED();
 }
 
+void EventLoopManagerWindows::register_process(pid_t pid, ESCAPING Function<void(pid_t)> handler)
+{
+    auto* thread_data = ThreadData::the();
+    VERIFY(thread_data);
+
+    auto& processes = thread_data->processes;
+    if (processes.contains(pid))
+        return;
+
+    HANDLE process_handle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
+    VERIFY(process_handle);
+
+    HANDLE job_object_handle = CreateJobObject(nullptr, nullptr);
+    VERIFY(job_object_handle);
+
+    BOOL succeeded = AssignProcessToJobObject(job_object_handle, process_handle);
+    VERIFY(succeeded);
+
+    auto process_data = make<EventLoopProcess>();
+    process_data->type = CompletionType::Process;
+    process_data->process.handle = process_handle;
+    process_data->pid = pid;
+    process_data->handler = move(handler);
+    process_data->jobobject.handle = job_object_handle;
+
+    JOBOBJECT_ASSOCIATE_COMPLETION_PORT joacp = { .CompletionKey = process_data.ptr(), .CompletionPort = thread_data->iocp.handle };
+    succeeded = SetInformationJobObject(job_object_handle, JobObjectAssociateCompletionPortInformation, &joacp, sizeof(JOBOBJECT_ASSOCIATE_COMPLETION_PORT));
+    VERIFY(succeeded);
+
+    processes.set(pid, move(process_data));
+}
+
+void EventLoopManagerWindows::unregister_process(pid_t pid)
+{
+    if (auto* thread_data = ThreadData::the()) {
+        auto maybe_process = thread_data->processes.take(pid);
+        if (!maybe_process.has_value())
+            return;
+        auto process_data = maybe_process.release_value();
+        JOBOBJECT_ASSOCIATE_COMPLETION_PORT joacp = { .CompletionKey = process_data, .CompletionPort = nullptr };
+        BOOL succeeded = SetInformationJobObject(process_data->jobobject.handle, JobObjectAssociateCompletionPortInformation, &joacp, sizeof(JOBOBJECT_ASSOCIATE_COMPLETION_PORT));
+        VERIFY(succeeded);
+    }
+}
+
 void EventLoopManagerWindows::did_post_event()
 {
 }

Libraries/LibCore/EventLoopImplementationWindows.h

@@ -27,6 +27,10 @@ class EventLoopManagerWindows final : public EventLoopManager {
 
     virtual int register_signal(int signal_number, Function<void(int)> handler) override;
     virtual void unregister_signal(int handler_id) override;
+
+    // Invokes the specified handler when the process exits
+    virtual void register_process(pid_t pid, ESCAPING Function<void(pid_t)> handler) override;
+    virtual void unregister_process(pid_t pid) override;
 };
 
 class EventLoopImplementationWindows final : public EventLoopImplementation {