+    freeCapabilityIOManager(cap->iomgr);

+#include "posix/MIO.h"

+            initCapabilityIOManagerSelect(iomgr);

+void freeCapabilityIOManager(CapIOManager *iomgr)

+{

+    switch (iomgr_type) {

+#if defined(IOMGR_ENABLED_SELECT)

+        case IO_MANAGER_SELECT:

+            freeCapabilityIOManagerSelect(iomgr);

+            break;

+#endif

+

+#if defined(IOMGR_ENABLED_POLL)

+        case IO_MANAGER_POLL:

+            freeCapabilityIOManagerPoll(iomgr);

+            break;

+#endif

+        default:

+            break;

+    }

+}

+

+

+void startIOManager(void)

+    debugTrace(DEBUG_iomanager, "starting %s I/O manager", showIOManager());

+restartIOManager(CapIOManager *iomgr, Capability **pcap)

+    debugTrace(DEBUG_iomanager, "Sending wakeup to I/O manager...");

+#if defined(IOMGR_ENABLED_SELECT)

+        case IO_MANAGER_SELECT:

+            wakeupIOManagerSelect(MainCapability.iomgr);

+            break;

+#endif

+

+#if defined(IOMGR_ENABLED_POLL)

+        case IO_MANAGER_POLL:

+            wakeupIOManagerPoll(MainCapability.iomgr);

+            break;

+#endif

+

+#if defined(IOMGR_ENABLED_WIN32_LEGACY)

+        case IO_MANAGER_WIN32_LEGACY:

+            abandonRequestWait();

+#endif

+        default:

+            barf("wakeupIOManager not implemented");

+    // FIXME: the post condition is now more complicated. Await can now simply

+    // be interrupted by wakeupIOManager.

+    // ASSERT(!emptyRunQueue(iomgr->cap) || getSchedState() != SCHED_RUNNING);

+/* When shutting down a capability, or after forkProcess, free the resources

+ * held by a CapIOManager to put it back into a state in which either it can be

+ * re-initialised using initCapabilityIOManager, or the whole structure freed.

+ *

+ * Note that this does not free the CapIOManager structure itself, just the

+ * contents.

+ *

+ * This is used during capability shutdown, during RTS shutdown. It is not used

+ * when reducing the number of capabilities. Capabilities are disabled rather

+ * than freed entirely: the I/O manager keeps running but threads that become

+ * runnable are migrated away.

+ *

+ * It is also used after forkProcess.

+ */

+void freeCapabilityIOManager(CapIOManager *iomgr);

+

+/* CapIOManager life cycle:

+ *

+ * alloc -> init -> free -> free struct

+ *           ^        |

+ *           +--------+

+ */

+void startIOManager(void);

+void restartIOManager(CapIOManager *iomgr,

+          /* inout */ Capability  **pcap);

+/* Wakeup hook: called from the scheduler's wakeUpRts().

+ * to the scheduler.

+ * This arranges to unblock the I/O manager if it was blocked waiting.

+#if defined(IOMGR_ENABLED_SELECT) || defined(IOMGR_ENABLED_POLL)

+    /* FDs for waking up the I/O manager when it is blocked waiting */

+    int wakeup_fd_r, wakeup_fd_w;

+#endif

+

+    /* Auxiliary table with size and indexes matching the aiop_table. This is

+     * aliased to the tail of the full poll table, which has a head entry for

+     * the wakeup_fd_r above, so we can also poll that fd.

+     */

+    struct pollfd *aiop_poll_table, *full_poll_table;

+    startIOManager();

+#if defined(FORKPROCESS_PRIMOP_SUPPORTED)

+static void truncateRunQueue(Capability *cap);

+#endif

+static StgTSO *popRunQueue (Capability *cap);

+

+

+            // Reset and re-initialise the capability's I/O manager,

+            // to get the I/O manager ready again.

+            //

+            // Any threads waiting on I/O or timers should have been

+            // removed from I/O manager queues by deleteThread_ above.

+            // TODO: but we could assert that here.

+            freeCapabilityIOManager(cap->iomgr);

+            initCapabilityIOManager(cap->iomgr);

+            // Release all caps except 0, we'll use that for restarting

+        restartIOManager(cap->iomgr, &cap);

+        // This approach also handles threads blocked on I/O. Such threads

+        // remain blocked, and when I/O completes and threads become runnable

+        // then they are migrated away.

+        //

+static StgTSO *popRunQueue (Capability *cap)

+#if defined(FORKPROCESS_PRIMOP_SUPPORTED)

+static void truncateRunQueue(Capability *cap)

+{

+    // Can only be called by the task owning the capability.

+    TSAN_ANNOTATE_BENIGN_RACE(&cap->run_queue_hd, "truncateRunQueue");

+    TSAN_ANNOTATE_BENIGN_RACE(&cap->run_queue_tl, "truncateRunQueue");

+    TSAN_ANNOTATE_BENIGN_RACE(&cap->n_run_queue, "truncateRunQueue");

+    cap->run_queue_hd = END_TSO_QUEUE;

+    cap->run_queue_tl = END_TSO_QUEUE;

+    cap->n_run_queue = 0;

+}

+#endif

+

+static void removeFromRunQueue (Capability *cap, StgTSO *tso)

+{

+    if (tso->block_info.prev == END_TSO_QUEUE) {

+        ASSERT(cap->run_queue_hd == tso);

+        cap->run_queue_hd = tso->_link;

+    } else {

+        setTSOLink(cap, tso->block_info.prev, tso->_link);

+    }

+    if (tso->_link == END_TSO_QUEUE) {

+        ASSERT(cap->run_queue_tl == tso);

+        cap->run_queue_tl = tso->block_info.prev;

+    } else {

+        setTSOPrev(cap, tso->_link, tso->block_info.prev);

+    }

+    tso->_link = tso->block_info.prev = END_TSO_QUEUE;

+    cap->n_run_queue--;

+

+    IF_DEBUG(sanity, checkRunQueue(cap));

+}

+

+void promoteInRunQueue (Capability *cap, StgTSO *tso)

+{

+    removeFromRunQueue(cap, tso);

+    pushOnRunQueue(cap, tso);

+}

+

+/* -----------------------------------------------------------------------------

+ *

+ * (c) The GHC Team 2025

+ *

+ * Utilities for a simple fd-based cross-thread wakeup mechanism.

+ *

+ * This is used in I/O managers, to provide a mechanism to wake them when they

+ * are blocked waiting on fds and timeouts. The mechanism works by including

+ * the read end fd into the set of fds the I/O manager waits on, and when a

+ * wake up is needed, the write end fd is used.

+ *

+ * This is implemented using either eventfd() or pipe().

+ *

+ * Linux 2.6.22+ and FreeBSD 13+ support eventfd. It is a single fd with a

+ * 64bit counter. It uses less resources than a pipe, and is probably a tad

+ * faster. Using write() adds to the counter, while read() reads and resets

+ * it. This gives us event combining.

+ *

+ * Otherwise we use a classic unix pipe.

+ *

+ * -------------------------------------------------------------------------*/

+

+#include "rts/PosixSource.h"

+#include "Rts.h"

+

+#include "FdWakeup.h"

+

+#include <fcntl.h>

+#include <unistd.h>

+

+#ifdef HAVE_SYS_EVENTFD_H

+#include <sys/eventfd.h>

+#endif

+

+#if !defined(HAVE_EVENTFD) \

+ || (defined(HAVE_EVENTFD) && !(defined(EFD_CLOEXEC) && defined(EFD_NONBLOCK)))

+static void fcntl_CLOEXEC_NONBLOCK(int fd)

+{

+    int res1 = fcntl(fd, F_SETFD, FD_CLOEXEC);

+    int res2 = fcntl(fd, F_SETFL, O_NONBLOCK);

+    if (RTS_UNLIKELY(res1 < 0 || res2 < 0)) {

+        sysErrorBelch("newFdWakeup fcntl()");

+        stg_exit(EXIT_FAILURE);

+    }

+}

+#endif

+

+void newFdWakeup(int *wakeup_fd_r, int *wakeup_fd_w)

+{

+#if defined(HAVE_EVENTFD)

+    int wakeup_fd;

+#if defined(EFD_CLOEXEC) && defined(EFD_NONBLOCK)

+    wakeup_fd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);

+#else

+    wakeup_fd = eventfd(0, 0);

+    if (wakeup_fd >= 0) fcntl_CLOEXEC_NONBLOCK(wakeup_fd);

+#endif

+    if (RTS_UNLIKELY(wakeup_fd < 0)) {

+        sysErrorBelch("newFdWakeup eventfd()");

+        stg_exit(EXIT_FAILURE);

+    }

+    /* eventfd uses the same fd for each end */

+    *wakeup_fd_r = wakeup_fd;

+    *wakeup_fd_w = wakeup_fd;

+#else

+    int pipefd[2];

+    int res;

+    res = pipe(pipefd);

+    if (RTS_UNLIKELY(res < 0)) {

+        sysErrorBelch("newFdWakeup pipe");

+        stg_exit(EXIT_FAILURE);

+    }

+    fcntl_CLOEXEC_NONBLOCK(pipefd[0]);

+    fcntl_CLOEXEC_NONBLOCK(pipefd[1]);

+    *wakeup_fd_r = pipefd[0]; /* read end */

+    *wakeup_fd_w = pipefd[1]; /* write end */

+#endif

+}

+

+void closeFdWakeup(int wakeup_fd_r, int wakeup_fd_w)

+{

+#if defined(HAVE_EVENTFD)

+    ASSERT(wakeup_fd_r == wakeup_fd_w);

+    close(wakeup_fd_r);

+#else

+    ASSERT(wakeup_fd_r != wakeup_fd_w);

+    close(wakeup_fd_r);

+    close(wakeup_fd_w);

+#endif

+}

+

+void sendFdWakeup(int wakeup_fd_w)

+{

+    int res;

+#if defined(HAVE_EVENTFD)

+    uint64_t val = 1;

+    res = write(wakeup_fd_w, &val, 8);

+#else

+    unsigned char buf = 1;

+    res = write(wakeup_fd_w, &buf, 1);

+#endif

+    if (RTS_UNLIKELY(res < 0)) {

+        /* Unlikely the pipe buffer will fill, but it would not be an error. */

+        if (errno == EAGAIN) return;

+        sysErrorBelch("sendFdWakeup write");

+        stg_exit(EXIT_FAILURE);

+    }

+}

+

+void collectFdWakeup(int wakeup_fd_r)

+{

+    int res;

+#if defined(HAVE_EVENTFD)

+    uint64_t buf;

+    /* eventfd combines events into one counter, so a single read is enough */

+    res = read(wakeup_fd_r, &buf, 8);

+#else

+    /* Drain the pipe buffer. Multiple wakeup notifications could

+     * have been sent before we have a chance to collect them.

+     */

+    uint64_t buf;

+    do {

+        res = read(wakeup_fd_r, &buf, 8);

+    } while (res == 8);

+#endif

+    if (RTS_UNLIKELY(res < 0)) {

+        /* After the first pipe read, it could block */

+        if (errno == EAGAIN) return;

+        sysErrorBelch("collectFdWakeup read");

+        stg_exit(EXIT_FAILURE);

+    }

+}

+/* -----------------------------------------------------------------------------

+ *

+ * (c) The GHC Team 2025

+ *

+ * Utilities for a simple fd-based cross-thread wakeup mechanism.

+ *

+ * This is used in I/O managers, to provide a mechanism to wake them when they

+ * are blocked waiting on fds and timeouts. The mechanism works by including

+ * the read end fd into the set of fds the I/O manager waits on, and when a

+ * wake up is needed, the write end fd is used.

+ *

+ * Prototypes for functions in FdWakeup.c

+ *

+ * -------------------------------------------------------------------------*/

+

+#pragma once

+

+#include "BeginPrivate.h"

+

+void newFdWakeup(int *fd_r, int *fd_w);

+void closeFdWakeup(int fd_r, int fd_w);

+

+void sendFdWakeup(int fd_w);

+void collectFdWakeup(int fd_r);

+

+#include "EndPrivate.h"

+

+/* -----------------------------------------------------------------------------

+ *

+ * (c) The GHC Team, 1998-2005

+ *

+ * Signal processing / handling.

+ *

+ * ---------------------------------------------------------------------------*/

+

+#include "rts/PosixSource.h"

+#include "Rts.h"

+

+#include "Schedule.h"

+#include "RtsUtils.h"

+#include "Prelude.h"

+#include "ThreadLabels.h"

+

+#include "MIO.h"

+#include "IOManager.h"

+#include "IOManagerInternals.h"

+

+#if defined(HAVE_ERRNO_H)

+# include <errno.h>

+#endif

+

+#include <stdlib.h>

+#include <unistd.h>

+

+// Here's the pipe into which we will send our signals

+static int io_manager_wakeup_fd = -1;

+static int timer_manager_control_wr_fd = -1;

+// TODO: Eliminate these globals. Put then into the CapIOManager, but the

+// problem is these are shared across all caps, not per cap.

+

+#define IO_MANAGER_WAKEUP 0xff

+#define IO_MANAGER_DIE    0xfe

+#define IO_MANAGER_SYNC   0xfd

+

+void setTimerManagerControlFd(int fd) {

+    RELAXED_STORE(&timer_manager_control_wr_fd, fd);

+}

+

+void

+setIOManagerWakeupFd (int fd)

+{

+    // only called when THREADED_RTS, but unconditionally

+    // compiled here because GHC.Event.Control depends on it.

+    SEQ_CST_STORE(&io_manager_wakeup_fd, fd);

+}

+

+#if defined(THREADED_RTS)

+void timerManagerNotifySignal(int sig, siginfo_t *info)

+{

+    StgWord8 buf[sizeof(siginfo_t) + 1];

+    int r;

+

+    buf[0] = sig;

+    if (info == NULL) {

+        // info may be NULL on Solaris (see #3790)

+        memset(buf+1, 0, sizeof(siginfo_t));

+    } else {

+        memcpy(buf+1, info, sizeof(siginfo_t));

+    }

+

+    int timer_control_fd = RELAXED_LOAD(&timer_manager_control_wr_fd);

+    if (0 <= timer_control_fd)

+    {

+        r = write(timer_control_fd, buf, sizeof(siginfo_t)+1);

+        if (r == -1 && errno == EAGAIN) {

+            errorBelch("lost signal due to full pipe: %d\n", sig);

+        }

+    }

+

+    // If the IO manager hasn't told us what the FD of the write end

+    // of its pipe is, there's not much we can do here, so just ignore

+    // the signal..

+}

+#endif

+

+

+/* -----------------------------------------------------------------------------

+ * Wake up at least one IO or timer manager HS thread.

+ * -------------------------------------------------------------------------- */

+void

+ioManagerWakeup (void)

+{

+    int r;

+    const int wakeup_fd = SEQ_CST_LOAD(&io_manager_wakeup_fd);

+    // Wake up the IO Manager thread by sending a byte down its pipe

+    if (wakeup_fd >= 0) {

+#if defined(HAVE_EVENTFD)

+        StgWord64 n = (StgWord64)IO_MANAGER_WAKEUP;

+        r = write(wakeup_fd, (char *) &n, 8);

+#else

+        StgWord8 byte = (StgWord8)IO_MANAGER_WAKEUP;

+        r = write(wakeup_fd, &byte, 1);

+#endif

+        /* N.B. If the TimerManager is shutting down as we run this

+         * then there is a possibility that our first read of

+         * io_manager_wakeup_fd is non-negative, but before we get to the

+         * write the file is closed. If this occurs, io_manager_wakeup_fd

+         * will be written into with -1 (GHC.Event.Control does this prior

+         * to closing), so checking this allows us to distinguish this case.

+         * To ensure we observe the correct ordering, we declare the

+         * io_manager_wakeup_fd as volatile.

+         * Since this is not an error condition, we do not print the error

+         * message in this case.

+         */

+        if (r == -1 && SEQ_CST_LOAD(&io_manager_wakeup_fd) >= 0) {

+            sysErrorBelch("ioManagerWakeup: write");

+        }

+    }

+}

+

+#if defined(THREADED_RTS)

+void

+ioManagerDie (void)

+{

+    StgWord8 byte = (StgWord8)IO_MANAGER_DIE;

+    uint32_t i;

+    int r;

+

+    {

+        // Shut down timer manager

+        const int fd = RELAXED_LOAD(&timer_manager_control_wr_fd);

+        if (0 <= fd) {

+            r = write(fd, &byte, 1);

+            if (r == -1) { sysErrorBelch("ioManagerDie: write"); }

+            RELAXED_STORE(&timer_manager_control_wr_fd, -1);

+        }

+    }

+

+    {

+        // Shut down IO managers

+        for (i=0; i < getNumCapabilities(); i++) {

+            const int fd = RELAXED_LOAD(&getCapability(i)->iomgr->control_fd);

+            if (0 <= fd) {

+                r = write(fd, &byte, 1);

+                if (r == -1) { sysErrorBelch("ioManagerDie: write"); }

+                RELAXED_STORE(&getCapability(i)->iomgr->control_fd, -1);

+            }

+        }

+    }

+}

+

+void

+ioManagerStartCap (Capability **cap)

+{

+    rts_evalIO(cap,ensureIOManagerIsRunning_closure,NULL);

+}

+

+void

+ioManagerStart (void)

+{

+    // Make sure the IO manager thread is running

+    Capability *cap;

+    if (SEQ_CST_LOAD(&timer_manager_control_wr_fd) < 0 || SEQ_CST_LOAD(&io_manager_wakeup_fd) < 0) {

+        cap = rts_lock();

+        ioManagerStartCap(&cap);

+        rts_unlock(cap);

+    }

+}

+#endif

+

+/* -----------------------------------------------------------------------------

+ *

+ * (c) The GHC Team, 1998-2005

+ *

+ * Signal processing / handling.

+ *

+ * ---------------------------------------------------------------------------*/

+

+#pragma once

+

+#include "IOManager.h"

+

+#if defined(HAVE_SIGNAL_H)

+# include <signal.h>

+#endif

+

+#include "BeginPrivate.h"

+

+/* Communicating with the IO manager thread (see GHC.Conc).

+ */

+void ioManagerWakeup (void);

+#if defined(THREADED_RTS)

+void ioManagerDie (void);

+void ioManagerStart (void);

+void ioManagerStartCap (/* inout */ Capability **cap);

+

+void timerManagerNotifySignal(int sig, siginfo_t *info);

+#endif

+

+#include "EndPrivate.h"

+#include "FdWakeup.h"

+    struct pollfd   *aiop_poll_table, *full_poll_table;

+    int wakeup_fd_r, wakeup_fd_w;

+We have both aiop_poll_table and full_poll_table. This is to cope with needing

+to wait on the special extra file descriptor wakeup_fd_r. This fd is used to

+support waking the I/O manager when we are blocked in a poll call. This

+requires waiting on an extra fd that has no corresponding entry in the

+aiop_table. To manage this quirk, we alias the aiop_poll_table to be the tail

+of the full_poll_table and have the first entry of the full_poll_table be the

+wakeup_fd_r. This means the aiop_poll_table indicies match up exactly with the

+aiop_table, but still allows the full_poll_table to have an extra entry.

+

+

+    newFdWakeup(&iomgr->wakeup_fd_r, &iomgr->wakeup_fd_w);

+

+    iomgr->full_poll_table = stgMallocBytes(sizeof(struct pollfd) /* size 1 */,

+                                            "initCapabilityIOManagerPoll");

+    iomgr->full_poll_table[0] = (struct pollfd) {

+                                  .fd      = iomgr->wakeup_fd_r,

+                                  .events  = POLLIN,

+                                  .revents = 0

+                                };

+    iomgr->aiop_poll_table = iomgr->full_poll_table+1; /* hence empty */

+}

+

+

+void freeCapabilityIOManagerPoll(CapIOManager *iomgr)

+{

+    stgFree(iomgr->full_poll_table);

+    closeFdWakeup(iomgr->wakeup_fd_r, iomgr->wakeup_fd_w);

+}

+

+

+void wakeupIOManagerPoll(CapIOManager *iomgr)

+{

+    sendFdWakeup(iomgr->wakeup_fd_w);

+static bool processIOCompletions(CapIOManager *iomgr, int ncompletions)

+

+    bool wakeup;

+    /* If the wakeup_fd_r is ready, collect it */

+    if (iomgr->full_poll_table[0].revents) {

+        ASSERT(iomgr->full_poll_table[0].fd == iomgr->wakeup_fd_r);

+        collectFdWakeup(iomgr->wakeup_fd_r);

+        ncompletions--;

+        wakeup = true;

+        debugTrace(DEBUG_iomanager, "Received wakeup in poll I/O manager.");

+    } else {

+        wakeup = false;

+    }

+

+    return wakeup;

+    ASSERT(iomgr->aiop_poll_table == iomgr->full_poll_table+1);

+

+        nfds_t nfds = sizeClosureTable(&iomgr->aiop_table) + 1;