curb 1.3.6 → 1.4.0

data/ext/curb_multi.c

@@ -32,6 +32,7 @@
 #include <sys/time.h>
 #include <time.h>
 #endif
+#include <limits.h>
 #include <stdint.h>
 #include <stdarg.h>
 
@@ -52,12 +53,50 @@
 #define CURB_MAYBE_UNUSED_DECL
 #endif
 
+/* Older rubies do not define UNDEF_P. */
+#ifndef UNDEF_P
+#define UNDEF_P(obj) ((VALUE)(obj) == Qundef)
+#endif
+
 #ifdef _WIN32
   // for O_RDWR and O_BINARY
   #include <fcntl.h>
 #endif
 
-#if defined(HAVE_CURL_MULTI_WAIT) && !defined(HAVE_RB_THREAD_FD_SELECT)
+/*
+ * Prefer curl_multi_poll for the blocking perform loop: it uses poll(), so it
+ * has no FD_SETSIZE limit (select-based waiting cannot see sockets numbered
+ * above 1024 and degrades to fixed sleeps), and curl_multi_wakeup lets the
+ * unblocking function end the wait immediately for Thread#raise, Thread#kill
+ * and signal delivery.
+ */
+#if defined(HAVE_CURL_MULTI_POLL) && defined(HAVE_CURL_MULTI_WAKEUP) && defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
+#define CURB_USE_MULTI_POLL 1
+#endif
+
+#ifdef CURB_USE_MULTI_POLL
+struct multi_poll_args {
+  CURLM *handle;
+  int timeout_ms;
+  int numfds;
+  CURLMcode code;
+};
+
+static void *curb_multi_poll_without_gvl(void *p) {
+  struct multi_poll_args *args = p;
+  args->code = curl_multi_poll(args->handle, NULL, 0, args->timeout_ms, &args->numfds);
+  return NULL;
+}
+
+/* Unblocking function: curl_multi_wakeup is safe to call from another thread
+ * while curl_multi_poll is blocked on the same handle. A wakeup that arrives
+ * after the poll returned only makes the next poll return early once. */
+static void curb_multi_poll_ubf(void *handle) {
+  curl_multi_wakeup((CURLM *)handle);
+}
+#endif
+
+#if defined(HAVE_CURL_MULTI_WAIT) && !defined(HAVE_RB_THREAD_FD_SELECT) && !defined(CURB_USE_MULTI_POLL)
 struct wait_args {
   CURLM *handle;
   long timeout_ms;
@@ -70,12 +109,101 @@ static void *curl_multi_wait_wrapper(void *p) {
 }
 #endif
 
+static VALUE cRubyFiber;
+static VALUE cRubyRactor;
+static ID id_fiber_blocking_p;
+static ID id_fiber_scheduler;
+static ID id_kernel_sleep;
+static ID id_io_wait;
+static ID id_ractor_current;
+static ID id_ractor_aref;
+static ID id_ractor_aset;
+static ID id_ractor_default_timeout_key;
+static ID id_ractor_autoclose_key;
+
+/*
+ * Ruby 3.0 introduced the Fiber scheduler at the Ruby level, but did not ship
+ * the public ruby/fiber/scheduler.h C API. Use the public C entry points when
+ * available and otherwise dispatch through Fiber and the scheduler object.
+ */
+static VALUE curb_fiber_scheduler_current(void) {
+#if defined(HAVE_RB_FIBER_SCHEDULER_CURRENT)
+  return rb_fiber_scheduler_current();
+#else
+  VALUE scheduler;
+
+  if (!rb_respond_to(cRubyFiber, id_fiber_scheduler)) return Qnil;
+
+  scheduler = rb_funcall(cRubyFiber, id_fiber_scheduler, 0);
+  if (NIL_P(scheduler)) return Qnil;
+
+  /* Fiber.scheduler returns the thread scheduler even from a blocking fiber,
+   * while rb_fiber_scheduler_current returns nil there. Match the latter so
+   * ordinary blocking fibers keep using the legacy multi loop. */
+  if (rb_respond_to(cRubyFiber, id_fiber_blocking_p) &&
+      RTEST(rb_funcall(cRubyFiber, id_fiber_blocking_p, 0))) {
+    return Qnil;
+  }
+
+  return scheduler;
+#endif
+}
+
+static VALUE curb_fiber_scheduler_kernel_sleep(VALUE scheduler, VALUE timeout) {
+#if defined(HAVE_RB_FIBER_SCHEDULER_KERNEL_SLEEP)
+  return rb_fiber_scheduler_kernel_sleep(scheduler, timeout);
+#else
+  return rb_funcall(scheduler, id_kernel_sleep, 1, timeout);
+#endif
+}
+
+static VALUE curb_fiber_scheduler_io_wait(VALUE scheduler, VALUE io, VALUE events, VALUE timeout) {
+#if defined(HAVE_RB_FIBER_SCHEDULER_IO_WAIT)
+  return rb_fiber_scheduler_io_wait(scheduler, io, events, timeout);
+#else
+  return rb_funcall(scheduler, id_io_wait, 3, io, events, timeout);
+#endif
+}
+
+/*
+ * Sleep for the given interval without stalling sibling fibers: when the
+ * current fiber runs under a fiber scheduler, wait via the scheduler's
+ * kernel_sleep hook. rb_thread_fd_select(0, ...) and rb_thread_wait_for are
+ * thread-level waits that never consult the scheduler, so they are only used
+ * when no scheduler is active.
+ */
+static void curb_multi_scheduler_sleep(struct timeval *tv) {
+  VALUE scheduler = curb_fiber_scheduler_current();
+  if (scheduler != Qnil) {
+    curb_fiber_scheduler_kernel_sleep(scheduler, rb_float_new((double)tv->tv_sec + ((double)tv->tv_usec / 1e6)));
+    return;
+  }
+#ifdef HAVE_RB_THREAD_FD_SELECT
+  {
+    struct timeval tv_sleep = *tv;
+    rb_thread_fd_select(0, NULL, NULL, NULL, &tv_sleep);
+  }
+#else
+  rb_thread_wait_for(*tv);
+#endif
+}
+
+/* Yield a nonblocking fiber without changing legacy behavior when no
+ * scheduler is active. */
+static void curb_multi_scheduler_yield(void) {
+  VALUE scheduler = curb_fiber_scheduler_current();
+  if (scheduler != Qnil) {
+    curb_fiber_scheduler_kernel_sleep(scheduler, INT2FIX(0));
+  }
+}
+
 extern VALUE mCurl;
 static VALUE idCall;
 static ID id_deferred_exception_ivar;
 static ID id_deferred_exception_source_id_ivar;
 static ID id_native_safety_signatures_ivar;
 static ID id_socket_io_cache_ivar;
+static ID id_socket_poller_io_ivar;
 
 #ifdef RDOC_NEVER_DEFINED
   mCurl = rb_define_module("Curl");
@@ -86,6 +214,32 @@ VALUE cCurlMulti;
 static long cCurlMutiDefaulttimeout = 100; /* milliseconds */
 static char cCurlMutiAutoClose = 0;
 
+/* Ruby 3.0+ provides storage owned by the current Ractor. Keep configurable
+ * defaults there so separate Ractors never race on process-global C values.
+ * Rubies without Ractor retain the historical process-wide settings. */
+static VALUE curb_multi_ractor_setting(ID key) {
+  VALUE current;
+
+  if (NIL_P(cRubyRactor)) return Qundef;
+  current = rb_funcall(cRubyRactor, id_ractor_current, 0);
+  return rb_funcall(current, id_ractor_aref, 1, ID2SYM(key));
+}
+
+static void curb_multi_set_ractor_setting(ID key, VALUE value) {
+  VALUE current = rb_funcall(cRubyRactor, id_ractor_current, 0);
+  rb_funcall(current, id_ractor_aset, 2, ID2SYM(key), value);
+}
+
+static long curb_multi_default_timeout(void) {
+  VALUE value = curb_multi_ractor_setting(id_ractor_default_timeout_key);
+  return (UNDEF_P(value) || NIL_P(value)) ? cCurlMutiDefaulttimeout : NUM2LONG(value);
+}
+
+static int curb_multi_autoclose_enabled(void) {
+  VALUE value = curb_multi_ractor_setting(id_ractor_autoclose_key);
+  return (UNDEF_P(value) || NIL_P(value)) ? cCurlMutiAutoClose == 1 : RTEST(value);
+}
+
 static void rb_curl_mutli_handle_complete(VALUE self, CURL *easy_handle, int result);
 static void rb_curl_multi_remove(ruby_curl_multi *rbcm, VALUE easy);
 static void rb_curl_multi_read_info(VALUE self, CURLM *mptr);
@@ -476,12 +630,18 @@ static VALUE ruby_curl_multi_initialize(VALUE self) {
  * call-seq:
  *   Curl::Multi.default_timeout = 4 => 4
  *
- * Set the global default time out for all Curl::Multi Handles.  This value is used
- * when libcurl cannot determine a timeout value when calling curl_multi_timeout.
+ * Set the default timeout for Curl::Multi handles in the current Ractor. On
+ * Rubies without Ractor this remains process-wide. This value is used when
+ * libcurl cannot determine a timeout value when calling curl_multi_timeout.
  *
  */
 VALUE ruby_curl_multi_set_default_timeout(VALUE klass, VALUE timeout) {
-  cCurlMutiDefaulttimeout = NUM2LONG(timeout);
+  long value = NUM2LONG(timeout);
+  if (NIL_P(cRubyRactor)) {
+    cCurlMutiDefaulttimeout = value;
+  } else {
+    curb_multi_set_ractor_setting(id_ractor_default_timeout_key, LONG2NUM(value));
+  }
   return timeout;
 }
 
@@ -489,23 +649,29 @@ VALUE ruby_curl_multi_set_default_timeout(VALUE klass, VALUE timeout) {
  * call-seq:
  *   Curl::Multi.default_timeout = 4 => 4
  *
- * Get the global default time out for all Curl::Multi Handles.
+ * Get the current Ractor's default timeout for Curl::Multi handles.
  *
  */
 VALUE ruby_curl_multi_get_default_timeout(VALUE klass) {
-  return LONG2NUM(cCurlMutiDefaulttimeout);
+  return LONG2NUM(curb_multi_default_timeout());
 }
 
 /*
  * call-seq:
  *   Curl::Multi.autoclose = true => true
  *
- * Automatically close open connections after each request. Otherwise, the connection will remain open 
- * for reuse until the next GC
+ * Automatically close open connections after each request in the current
+ * Ractor. Otherwise, the connection will remain open for reuse until the next
+ * GC.
  *
  */
 VALUE ruby_curl_multi_set_autoclose(VALUE klass, VALUE onoff) {
-  cCurlMutiAutoClose = ((onoff == Qtrue) ? 1 : 0);
+  VALUE value = onoff == Qtrue ? Qtrue : Qfalse;
+  if (NIL_P(cRubyRactor)) {
+    cCurlMutiAutoClose = RTEST(value) ? 1 : 0;
+  } else {
+    curb_multi_set_ractor_setting(id_ractor_autoclose_key, value);
+  }
   return onoff;
 }
 
@@ -513,11 +679,11 @@ VALUE ruby_curl_multi_set_autoclose(VALUE klass, VALUE onoff) {
  * call-seq:
  *   Curl::Multi.autoclose => true|false
  *
- * Get the global default autoclose setting for all Curl::Multi Handles.
+ * Get the current Ractor's default autoclose setting for Curl::Multi handles.
  *
  */
 VALUE ruby_curl_multi_get_autoclose(VALUE klass) {
-  return cCurlMutiAutoClose == 1 ? Qtrue : Qfalse;
+  return curb_multi_autoclose_enabled() ? Qtrue : Qfalse;
 }
 
 /*
@@ -652,7 +818,7 @@ VALUE ruby_curl_multi_add(VALUE self, VALUE easy) {
     }
   }
 
-  rbce->multi_attachment_generation++;
+  rbce->multi_attachment_generation = ++rbcm->attachment_sequence;
   st_insert(rbcm->attached, (st_data_t)rbce, (st_data_t)easy);
 
   /* track a reference to associated multi handle */
@@ -772,42 +938,17 @@ struct multi_complete_callback_args {
   ruby_curl_multi *rbcm;
   ruby_curl_easy *rbce;
   int result;
-  st_table *attached_snapshot;
+  /* rbcm->attachment_sequence before the callbacks ran; easies stamped later
+   * were attached (or re-attached) by the callbacks. */
+  unsigned long attachment_sequence_before;
 };
 
-static int snapshot_attached_easy_i(st_data_t key, st_data_t val, st_data_t arg) {
-  st_table *snapshot = (st_table *)arg;
-  ruby_curl_easy *rbce = (ruby_curl_easy *)key;
-
-  if (!rbce) {
-    return ST_CONTINUE;
-  }
-
-  st_insert(snapshot, key, (st_data_t)rbce->multi_attachment_generation);
-  return ST_CONTINUE;
-}
-
-static st_table *capture_attached_easy_snapshot(ruby_curl_multi *rbcm) {
-  st_table *snapshot = st_init_numtable();
-
-  if (!snapshot) {
-    rb_raise(rb_eNoMemError, "Failed to allocate multi callback snapshot table");
-  }
-
-  if (rbcm && rbcm->attached) {
-    st_foreach(rbcm->attached, snapshot_attached_easy_i, (st_data_t)snapshot);
-  }
-
-  return snapshot;
-}
-
 struct collect_new_attached_easies_ctx {
-  st_table *snapshot;
+  unsigned long attachment_sequence_before;
   VALUE easies;
 };
 
 static int collect_new_attached_easies_i(st_data_t key, st_data_t val, st_data_t arg) {
-  st_data_t existing = 0;
   ruby_curl_easy *rbce = (ruby_curl_easy *)key;
   struct collect_new_attached_easies_ctx *ctx = (struct collect_new_attached_easies_ctx *)arg;
 
@@ -815,24 +956,25 @@ static int collect_new_attached_easies_i(st_data_t key, st_data_t val, st_data_t
     return ST_CONTINUE;
   }
 
-  if (!ctx->snapshot || !st_lookup(ctx->snapshot, key, &existing) ||
-      existing != (st_data_t)rbce->multi_attachment_generation) {
+  if (rbce->multi_attachment_generation > ctx->attachment_sequence_before) {
     rb_ary_push(ctx->easies, (VALUE)val);
   }
 
   return ST_CONTINUE;
 }
 
-static void rb_curl_multi_remove_added_easies_since_snapshot(VALUE self, ruby_curl_multi *rbcm, st_table *snapshot) {
+/* Only runs when a completion callback raised, so this walk over the
+ * attached table stays off the per-completion path. */
+static void rb_curl_multi_remove_easies_attached_since(VALUE self, ruby_curl_multi *rbcm, unsigned long attachment_sequence_before) {
   struct collect_new_attached_easies_ctx ctx;
   VALUE easies = rb_ary_new();
   long index;
 
-  if (!rbcm || !snapshot || !rbcm->attached) {
+  if (!rbcm || !rbcm->attached) {
     return;
   }
 
-  ctx.snapshot = snapshot;
+  ctx.attachment_sequence_before = attachment_sequence_before;
   ctx.easies = easies;
   st_foreach(rbcm->attached, collect_new_attached_easies_i, (st_data_t)&ctx);
 
@@ -869,7 +1011,7 @@ static void stash_and_raise_status_callback_error_if_unmasked(struct multi_compl
   }
 
   stash_multi_exception_if_unset(args->self, exception, args->easy);
-  rb_curl_multi_remove_added_easies_since_snapshot(args->self, args->rbcm, args->attached_snapshot);
+  rb_curl_multi_remove_easies_attached_since(args->self, args->rbcm, args->attachment_sequence_before);
   rb_exc_raise(exception);
 }
 
@@ -972,11 +1114,6 @@ static VALUE rb_curl_multi_finish_completion_callbacks(VALUE argp) {
     args->rbce->multi = Qnil;
   }
 
-  if (args->attached_snapshot) {
-    st_free_table(args->attached_snapshot);
-    args->attached_snapshot = NULL;
-  }
-
   return Qnil;
 }
 
@@ -1037,7 +1174,7 @@ static void rb_curl_mutli_handle_complete(VALUE self, CURL *easy_handle, int res
     rbcm,
     rbce,
     result,
-    capture_attached_easy_snapshot(rbcm)
+    rbcm->attachment_sequence
   };
   rb_ensure(rb_curl_multi_run_completion_callbacks, (VALUE)&args,
             rb_curl_multi_finish_completion_callbacks, (VALUE)&args);
@@ -1084,21 +1221,14 @@ static void rb_curl_multi_run(VALUE self, CURLM *multi_handle, int *still_runnin
   CURLMcode mcode;
 
   /*
-   * curl_multi_perform will return CURLM_CALL_MULTI_PERFORM only when it wants to be called again immediately.
-   * When things are fine and there is nothing immediate it wants done, it'll return CURLM_OK.
-   *
-   * It will perform all pending actions on all added easy handles attached to this multi handle. We will loop
-   * here as long as mcode is CURLM_CALL_MULTIPERFORM.
-   */
-  do {
-    mcode = curl_multi_perform(multi_handle, still_running);
-  } while (mcode == CURLM_CALL_MULTI_PERFORM);
-
-  /*
-   * Nothing more to do, check if an error occured in the loop above and raise an exception if necessary.
+   * Perform all pending actions on every easy handle attached to this multi
+   * handle. libcurl stopped returning CURLM_CALL_MULTI_PERFORM here in 7.20
+   * (curb supports 7.58+); should it appear, treat it as success: the drive
+   * loop calls curl_multi_perform again on its next pass.
    */
+  mcode = curl_multi_perform(multi_handle, still_running);
 
-  if (mcode != CURLM_OK) {
+  if (mcode != CURLM_OK && mcode != CURLM_CALL_MULTI_PERFORM) {
     raise_curl_multi_error_exception(mcode);
   }
 
@@ -1113,10 +1243,36 @@ static void rb_curl_multi_run(VALUE self, CURLM *multi_handle, int *still_runnin
 
 #if defined(HAVE_CURL_MULTI_SOCKET_ACTION) && defined(HAVE_CURLMOPT_SOCKETFUNCTION) && defined(HAVE_CURLMOPT_TIMERFUNCTION) && defined(HAVE_RB_THREAD_FD_SELECT) && !defined(_WIN32)
 /* ---- socket-action implementation (scheduler-friendly) ---- */
+
+/*
+ * Under a fiber scheduler, mirror libcurl's socket interest into a kernel
+ * event queue (epoll or kqueue) and wait on that single descriptor with the
+ * scheduler's io_wait hook. Every scheduler implements io_wait, so this avoids
+ * the optional io_select hook (which Async implements by starting a thread
+ * per call) and the one-descriptor fallback for schedulers without it.
+ */
+#if defined(HAVE_SYS_EPOLL_H) && defined(HAVE_EPOLL_CREATE1)
+#include <sys/epoll.h>
+#define CURB_SOCKET_POLLER 1
+#define CURB_SOCKET_POLLER_EPOLL 1
+#define CURB_SOCKET_POLLER_NAME "epoll"
+#elif defined(HAVE_SYS_EVENT_H) && defined(HAVE_KQUEUE)
+#include <sys/types.h>
+#include <sys/event.h>
+#define CURB_SOCKET_POLLER 1
+#define CURB_SOCKET_POLLER_KQUEUE 1
+#define CURB_SOCKET_POLLER_NAME "kqueue"
+#endif
+
+/* Events harvested per poller read; more are collected on following rounds. */
+#define CURB_SOCKET_POLLER_BATCH 64
+
 typedef struct {
   st_table *sock_map;     /* key: int fd, value: int 'what' (CURL_POLL_*) */
   long long timeout_deadline_ms; /* absolute deadline for CURL_SOCKET_TIMEOUT */
   VALUE io_cache;         /* fd -> IO wrapper for fiber-scheduler waits */
+  int poller_fd;          /* epoll/kqueue descriptor, or -1 when unused */
+  VALUE poller_io;        /* IO wrapper for poller_fd passed to io_wait */
 } multi_socket_ctx;
 
 static long long multi_socket_current_time_ms(void) {
@@ -1172,30 +1328,6 @@ static const char *cselect_flags_str(int flags, char *buf, size_t n) {
 #define cselect_flags_str(...) ""
 #endif
 
-#if defined(HAVE_RB_FIBER_SCHEDULER_IO_WAIT) && defined(HAVE_RB_FIBER_SCHEDULER_CURRENT)
-/* Protected call to rb_fiber_scheduler_io_wait to avoid unwinding into C on TypeError. */
-struct fiber_io_wait_args { VALUE scheduler; VALUE io; VALUE events; VALUE timeout; };
-static VALUE fiber_io_wait_protected(VALUE argp) {
-  struct fiber_io_wait_args *a = (struct fiber_io_wait_args *)argp;
-  return rb_fiber_scheduler_io_wait(a->scheduler, a->io, a->events, a->timeout);
-}
-#endif
-
-#if defined(HAVE_RB_FIBER_SCHEDULER_IO_SELECT) && defined(HAVE_RB_FIBER_SCHEDULER_CURRENT)
-struct fiber_io_select_args {
-  VALUE scheduler;
-  VALUE readables;
-  VALUE writables;
-  VALUE exceptables;
-  VALUE timeout;
-};
-
-static VALUE fiber_io_select_protected(VALUE argp) {
-  struct fiber_io_select_args *a = (struct fiber_io_select_args *)argp;
-  return rb_fiber_scheduler_io_select(a->scheduler, a->readables, a->writables, a->exceptables, a->timeout);
-}
-#endif
-
 #if defined(RB_INTEGER_TYPE_P)
 #define CURB_INTEGER_P(value) RB_INTEGER_TYPE_P(value)
 #else
@@ -1231,12 +1363,77 @@ static int multi_socket_cselect_flags_for_wait_events(int events) {
   return flags;
 }
 
+#ifdef CURB_SOCKET_POLLER
+static int multi_socket_poller_create(void) {
+#if defined(CURB_SOCKET_POLLER_EPOLL)
+  return epoll_create1(EPOLL_CLOEXEC);
+#else
+  int fd = kqueue();
+  if (fd >= 0) fcntl(fd, F_SETFD, FD_CLOEXEC);
+  return fd;
+#endif
+}
+
+/*
+ * Bring the poller's interest for fd from old_what to new_what, where each is
+ * a CURL_POLL_IN/OUT/INOUT mask and 0 means "not registered". Registration is
+ * level-triggered so readiness left unconsumed is reported again. Errors are
+ * ignored: the kernel drops closed descriptors from both epoll and kqueue on
+ * its own, so a stale delete or a re-add after fd reuse is harmless.
+ */
+static void multi_socket_poller_update(multi_socket_ctx *ctx, int fd, int old_what, int new_what) {
+  if (!ctx || ctx->poller_fd < 0 || old_what == new_what) return;
+#if defined(CURB_SOCKET_POLLER_EPOLL)
+  {
+    struct epoll_event ev;
+    memset(&ev, 0, sizeof(ev));
+    ev.data.fd = fd;
+    if (new_what & CURL_POLL_IN) ev.events |= EPOLLIN;
+    if (new_what & CURL_POLL_OUT) ev.events |= EPOLLOUT;
+
+    if (new_what == 0) {
+      epoll_ctl(ctx->poller_fd, EPOLL_CTL_DEL, fd, &ev);
+    } else if (old_what == 0) {
+      if (epoll_ctl(ctx->poller_fd, EPOLL_CTL_ADD, fd, &ev) != 0 && errno == EEXIST) {
+        epoll_ctl(ctx->poller_fd, EPOLL_CTL_MOD, fd, &ev);
+      }
+    } else if (epoll_ctl(ctx->poller_fd, EPOLL_CTL_MOD, fd, &ev) != 0 && errno == ENOENT) {
+      epoll_ctl(ctx->poller_fd, EPOLL_CTL_ADD, fd, &ev);
+    }
+  }
+#else
+  {
+    /* kqueue tracks read and write as separate filters. Apply each change on
+     * its own so one failing change cannot skip the others. */
+    struct kevent change;
+    int old_read = (old_what & CURL_POLL_IN) != 0;
+    int new_read = (new_what & CURL_POLL_IN) != 0;
+    int old_write = (old_what & CURL_POLL_OUT) != 0;
+    int new_write = (new_what & CURL_POLL_OUT) != 0;
+
+    if (old_read != new_read) {
+      EV_SET(&change, fd, EVFILT_READ, new_read ? EV_ADD : EV_DELETE, 0, 0, NULL);
+      kevent(ctx->poller_fd, &change, 1, NULL, 0, NULL);
+    }
+    if (old_write != new_write) {
+      EV_SET(&change, fd, EVFILT_WRITE, new_write ? EV_ADD : EV_DELETE, 0, 0, NULL);
+      kevent(ctx->poller_fd, &change, 1, NULL, 0, NULL);
+    }
+  }
+#endif
+}
+#endif
+
 static void multi_socket_forget_fd(multi_socket_ctx *ctx, int fd) {
   st_data_t key = (st_data_t)fd;
   st_data_t rec;
 
   if (!ctx) return;
-  if (ctx->sock_map) st_delete(ctx->sock_map, &key, &rec);
+  if (ctx->sock_map && st_delete(ctx->sock_map, &key, &rec)) {
+#ifdef CURB_SOCKET_POLLER
+    multi_socket_poller_update(ctx, fd, (int)rec, 0);
+#endif
+  }
   if (!NIL_P(ctx->io_cache)) rb_hash_delete(ctx->io_cache, INT2NUM(fd));
 }
 
@@ -1266,10 +1463,14 @@ static int multi_socket_cb(CURL *easy, curl_socket_t s, int what, void *userp, v
   } else {
     /* store current interest mask for this fd */
     st_data_t key = (st_data_t)fd;
-    st_data_t old_what;
-    if (st_lookup(ctx->sock_map, key, &old_what) && (int)old_what != what && !NIL_P(ctx->io_cache)) {
+    st_data_t old_what = 0;
+    int tracked = st_lookup(ctx->sock_map, key, &old_what);
+    if (tracked && (int)old_what != what && !NIL_P(ctx->io_cache)) {
       rb_hash_delete(ctx->io_cache, INT2NUM(fd));
     }
+#ifdef CURB_SOCKET_POLLER
+    multi_socket_poller_update(ctx, fd, tracked ? (int)old_what : 0, what);
+#endif
     st_insert(ctx->sock_map, (st_data_t)fd, (st_data_t)what);
 #if CURB_SOCKET_DEBUG
     {
@@ -1349,13 +1550,6 @@ static int st_pick_one_i(st_data_t key, st_data_t val, st_data_t argp) {
   s->found = 1;
   return ST_STOP;
 }
-struct counter_state { int count; };
-static int st_count_i(st_data_t k, st_data_t v, st_data_t argp) {
-  (void)k; (void)v;
-  struct counter_state *c = (struct counter_state *)argp;
-  c->count++;
-  return ST_CONTINUE;
-}
 
 static const char *multi_socket_io_mode_for_curl_poll(int what) {
   if (what == CURL_POLL_IN) return "r";
@@ -1380,6 +1574,112 @@ static VALUE multi_socket_io_for_fd_protected(VALUE argp) {
   return multi_socket_io_for_fd(a->ctx, a->fd, a->what);
 }
 
+#ifdef CURB_SOCKET_POLLER
+static VALUE multi_socket_poller_io(VALUE self, multi_socket_ctx *ctx) {
+  if (NIL_P(ctx->poller_io)) {
+    VALUE io = rb_funcall(rb_cIO, rb_intern("for_fd"), 2, INT2NUM(ctx->poller_fd), rb_str_new_cstr("r"));
+    /* The drive loop's ensure closes poller_fd itself. */
+    rb_funcall(io, rb_intern("autoclose="), 1, Qfalse);
+    ctx->poller_io = io;
+    rb_ivar_set(self, id_socket_poller_io_ivar, io);
+  }
+  return ctx->poller_io;
+}
+
+/*
+ * Report readiness the way select() does: an error or hangup marks the socket
+ * ready for whatever libcurl is waiting on, and libcurl then observes the
+ * condition from the read or write itself. (CURL_CSELECT_ERR would make it
+ * fail the transfer outright, even with response data still buffered.)
+ */
+static int multi_socket_poller_flags(int ready_in, int ready_out, int failed, int what) {
+  int flags = 0;
+
+  if (ready_in) flags |= CURL_CSELECT_IN;
+  if (ready_out) flags |= CURL_CSELECT_OUT;
+  if (failed) flags |= multi_socket_cselect_flags_for_curl_poll(what);
+
+  return flags;
+}
+
+static void multi_socket_poller_act(ruby_curl_multi *rbcm, multi_socket_ctx *ctx, int fd, int ready_in, int ready_out, int failed, int *dispatched) {
+  st_data_t what;
+  int flags;
+  CURLMcode mrc;
+
+  /* An earlier action in this batch may have made libcurl drop the socket. */
+  if (!st_lookup(ctx->sock_map, (st_data_t)fd, &what)) return;
+
+  flags = multi_socket_poller_flags(ready_in, ready_out, failed, (int)what);
+  if (!flags) return;
+
+#if CURB_SOCKET_DEBUG
+  {
+    char b[32];
+    curb_debugf("[curb.socket] poller socket_action fd=%d flags=%s", fd, cselect_flags_str(flags, b, sizeof(b)));
+  }
+#endif
+  mrc = curl_multi_socket_action(rbcm->handle, (curl_socket_t)fd, flags, &rbcm->running);
+  if (mrc != CURLM_OK) raise_curl_multi_error_exception(mrc);
+  (*dispatched)++;
+}
+
+/* Collect pending poller events without blocking and hand each ready socket
+ * to libcurl. Returns the number of socket actions performed. */
+static int multi_socket_poller_dispatch(ruby_curl_multi *rbcm, multi_socket_ctx *ctx) {
+  int dispatched = 0;
+  int rounds = 0;
+  /* kqueue reports read and write readiness as separate events. */
+  int max_rounds = (int)((ctx->sock_map->num_entries * 2) / CURB_SOCKET_POLLER_BATCH) + 1;
+  int n, i;
+
+  do {
+#if defined(CURB_SOCKET_POLLER_EPOLL)
+    struct epoll_event events[CURB_SOCKET_POLLER_BATCH];
+    n = epoll_wait(ctx->poller_fd, events, CURB_SOCKET_POLLER_BATCH, 0);
+    if (n < 0) {
+      if (errno != EINTR) rb_sys_fail("epoll_wait");
+      n = 0;
+    }
+    for (i = 0; i < n; i++) {
+      uint32_t ev = events[i].events;
+      multi_socket_poller_act(rbcm, ctx, events[i].data.fd,
+                              (ev & EPOLLIN) != 0, (ev & EPOLLOUT) != 0,
+                              (ev & (EPOLLERR | EPOLLHUP)) != 0, &dispatched);
+    }
+#else
+    struct kevent events[CURB_SOCKET_POLLER_BATCH];
+    struct timespec no_wait = {0, 0};
+    n = kevent(ctx->poller_fd, NULL, 0, events, CURB_SOCKET_POLLER_BATCH, &no_wait);
+    if (n < 0) {
+      if (errno != EINTR) rb_sys_fail("kevent");
+      n = 0;
+    }
+    for (i = 0; i < n; i++) {
+      if (events[i].flags & EV_ERROR) continue;
+      multi_socket_poller_act(rbcm, ctx, (int)events[i].ident,
+                              events[i].filter == EVFILT_READ, events[i].filter == EVFILT_WRITE,
+                              0, &dispatched);
+    }
+#endif
+  } while (n == CURB_SOCKET_POLLER_BATCH && ++rounds < max_rounds);
+
+  return dispatched;
+}
+
+/* Wait for any tracked socket through the scheduler's io_wait hook on the
+ * poller descriptor, then dispatch whatever became ready. */
+static int multi_socket_poller_wait(VALUE self, ruby_curl_multi *rbcm, multi_socket_ctx *ctx, VALUE scheduler, struct timeval *tv) {
+  VALUE io = multi_socket_poller_io(self, ctx);
+  double timeout_s = (double)tv->tv_sec + ((double)tv->tv_usec / 1e6);
+
+  /* The hook's return value varies across schedulers; the non-blocking
+   * dispatch below is the source of truth for what is ready. */
+  curb_fiber_scheduler_io_wait(scheduler, io, INT2NUM(RB_WAITFD_IN), rb_float_new(timeout_s));
+  return multi_socket_poller_dispatch(rbcm, ctx);
+}
+#endif
+
 #if defined(HAVE_RB_FIBER_SCHEDULER_IO_SELECT) && defined(HAVE_RB_FIBER_SCHEDULER_CURRENT)
 struct build_io_select_arrays_args {
   multi_socket_ctx *ctx;
@@ -1387,6 +1687,7 @@ struct build_io_select_arrays_args {
   VALUE writables;
   VALUE exceptables;
   int failed;
+  int state;
 };
 
 static int build_io_select_arrays_i(st_data_t key, st_data_t val, st_data_t argp) {
@@ -1405,12 +1706,7 @@ static int build_io_select_arrays_i(st_data_t key, st_data_t val, st_data_t argp
   io = rb_protect(multi_socket_io_for_fd_protected, (VALUE)&io_args, &io_state);
   if (io_state || NIL_P(io)) {
     if (io_state) {
-#if CURB_SOCKET_DEBUG
-      VALUE err = rb_errinfo();
-      VALUE msg = rb_obj_as_string(err);
-      curb_debugf("[curb.socket] IO.for_fd failed: %s: %s", rb_obj_classname(err), StringValueCStr(msg));
-#endif
-      rb_set_errinfo(Qnil);
+      a->state = io_state;
     }
     a->failed = 1;
     return ST_STOP;
@@ -1455,16 +1751,19 @@ static int collect_io_select_ready_i(st_data_t key, st_data_t val, st_data_t arg
 #endif
 
 static void rb_curl_multi_socket_drive(VALUE self, ruby_curl_multi *rbcm, multi_socket_ctx *ctx, VALUE block) {
-  /* prime the state: let libcurl act on timeouts to setup sockets */
-  CURLMcode mrc = curl_multi_socket_action(rbcm->handle, CURL_SOCKET_TIMEOUT, 0, &rbcm->running);
-  if (mrc != CURLM_OK) raise_curl_multi_error_exception(mrc);
-  curb_debugf("[curb.socket] drive: initial socket_action timeout -> mrc=%d running=%d", mrc, rbcm->running);
-  rb_curl_multi_read_info(self, rbcm->handle);
-  rb_curl_multi_yield_if_given(self, block);
+  CURLMcode mrc;
+
+  do {
+    /* Prime the state: let libcurl act on timeouts to set up sockets. */
+    mrc = curl_multi_socket_action(rbcm->handle, CURL_SOCKET_TIMEOUT, 0, &rbcm->running);
+    if (mrc != CURLM_OK) raise_curl_multi_error_exception(mrc);
+    curb_debugf("[curb.socket] drive: initial socket_action timeout -> mrc=%d running=%d", mrc, rbcm->running);
+    rb_curl_multi_read_info(self, rbcm->handle);
+    rb_curl_multi_yield_if_given(self, block);
 
-  while (rbcm->running) {
+    while (rbcm->running) {
     struct timeval tv = {0, 0};
-    long wait_ms = cCurlMutiDefaulttimeout;
+    long wait_ms = curb_multi_default_timeout();
 
     if (multi_socket_timer_due(ctx)) {
       ctx->timeout_deadline_ms = -1;
@@ -1473,6 +1772,10 @@ static void rb_curl_multi_socket_drive(VALUE self, ruby_curl_multi *rbcm, multi_
       if (mrc != CURLM_OK) raise_curl_multi_error_exception(mrc);
       rb_curl_multi_read_info(self, rbcm->handle);
       rb_curl_multi_yield_if_given(self, block);
+      if (rbcm->running && multi_socket_timer_due(ctx)) {
+        /* A repeatedly rearmed 0ms timer must still let sibling fibers run. */
+        curb_multi_scheduler_yield();
+      }
       continue;
     }
 
@@ -1492,13 +1795,7 @@ static void rb_curl_multi_socket_drive(VALUE self, ruby_curl_multi *rbcm, multi_
       if (st.found) { wait_fd = st.fd; wait_what = st.what; }
     }
 
-    /* Count tracked fds for logging */
-    int count_tracked = 0;
-    if (ctx->sock_map) {
-      struct counter_state cs = { 0 };
-      st_foreach(ctx->sock_map, st_count_i, (st_data_t)&cs);
-      count_tracked = cs.count;
-    }
+    int count_tracked = ctx->sock_map ? (int)ctx->sock_map->num_entries : 0;
 
     curb_debugf("[curb.socket] wait phase: tracked_fds=%d fd=%d what=%d tv=%ld.%06ld", count_tracked, wait_fd, wait_what, (long)tv.tv_sec, (long)tv.tv_usec);
 
@@ -1507,29 +1804,42 @@ static void rb_curl_multi_socket_drive(VALUE self, ruby_curl_multi *rbcm, multi_
     int ready_flags = 0;
 
 	    int handled_wait = 0;
-	    if (count_tracked > 1) {
+#ifdef CURB_SOCKET_POLLER
+	    if (count_tracked > 0 && ctx->poller_fd >= 0) {
+	      VALUE scheduler = curb_fiber_scheduler_current();
+	      if (scheduler != Qnil) {
+	        /* Ready sockets are dispatched inside, so any_ready stays 0 and
+	         * the single-fd dispatch below is skipped. */
+	        int dispatched = multi_socket_poller_wait(self, rbcm, ctx, scheduler, &tv);
+	        curb_debugf("[curb.socket] poller wait dispatched=%d", dispatched);
+	        did_timeout = !dispatched && multi_socket_timer_due(ctx);
+	        handled_wait = 1;
+	      }
+	    }
+#endif
+	    if (handled_wait) {
+	      /* The poller already waited and dispatched. */
+	    } else if (count_tracked > 1) {
 #if defined(HAVE_RB_FIBER_SCHEDULER_IO_SELECT) && defined(HAVE_RB_FIBER_SCHEDULER_CURRENT)
 	      {
-	        VALUE scheduler = rb_fiber_scheduler_current();
+	        VALUE scheduler = curb_fiber_scheduler_current();
 	        if (scheduler != Qnil) {
 	          VALUE readables = rb_ary_new();
 	          VALUE writables = rb_ary_new();
 	          VALUE exceptables = rb_ary_new();
-	          struct build_io_select_arrays_args build_args = { ctx, readables, writables, exceptables, 0 };
+	          struct build_io_select_arrays_args build_args = { ctx, readables, writables, exceptables, 0, 0 };
 	          st_foreach(ctx->sock_map, build_io_select_arrays_i, (st_data_t)&build_args);
+	          if (build_args.state) rb_jump_tag(build_args.state);
 	          if (!build_args.failed) {
 	            double timeout_s = (double)tv.tv_sec + ((double)tv.tv_usec / 1e6);
 	            VALUE timeout = rb_float_new(timeout_s);
-	            struct fiber_io_select_args select_args = { scheduler, readables, writables, exceptables, timeout };
-	            int state = 0;
-	            VALUE ready = rb_protect(fiber_io_select_protected, (VALUE)&select_args, &state);
-	            if (state) {
-#if CURB_SOCKET_DEBUG
-	              VALUE err = rb_errinfo();
-	              VALUE msg = rb_obj_as_string(err);
-	              curb_debugf("[curb.socket] scheduler io_select failed: %s: %s", rb_obj_classname(err), StringValueCStr(msg));
-#endif
-	              rb_set_errinfo(Qnil);
+	            VALUE ready = rb_fiber_scheduler_io_select(scheduler, readables, writables, exceptables, timeout);
+	            if (UNDEF_P(ready)) {
+	              /* The scheduler does not implement the optional io_select hook:
+	               * rb_fiber_scheduler_io_select returns Qundef immediately.
+	               * Leave handled_wait unset so the io_wait fallback below can
+	               * perform a cooperative wait. */
+	              curb_debugf("[curb.socket] scheduler io_select not implemented; falling back to io_wait");
 	            } else {
 	              handled_wait = 1;
 	              any_ready = RB_TYPE_P(ready, T_ARRAY);
@@ -1568,8 +1878,36 @@ static void rb_curl_multi_socket_drive(VALUE self, ruby_curl_multi *rbcm, multi_
 	        }
 	      }
 #endif
+	      /* Ruby versions without the public io_select C API, and newer
+	       * schedulers that omit the optional hook, wait cooperatively on one
+	       * representative descriptor, then use a zero-time select below to
+	       * collect readiness across the whole set. */
+	      if (!handled_wait && wait_fd >= 0) {
+	        VALUE scheduler = curb_fiber_scheduler_current();
+	        if (scheduler != Qnil) {
+	          if (!multi_socket_fd_valid_p(wait_fd)) {
+	            multi_socket_forget_fd(ctx, wait_fd);
+	            did_timeout = 1;
+	            handled_wait = 1;
+	          } else {
+	            struct io_for_fd_args io_args = { ctx, wait_fd, wait_what };
+	            int io_state = 0;
+	            VALUE io = rb_protect(multi_socket_io_for_fd_protected, (VALUE)&io_args, &io_state);
+	            if (io_state) rb_jump_tag(io_state);
+	            if (!NIL_P(io)) {
+	              int events = multi_socket_wait_events_for_curl_poll(wait_what);
+	              double timeout_s = (double)tv.tv_sec + ((double)tv.tv_usec / 1e6);
+	              curb_fiber_scheduler_io_wait(scheduler, io, INT2NUM(events), rb_float_new(timeout_s));
+	              tv.tv_sec = 0;
+	              tv.tv_usec = 0;
+	            }
+	          }
+	        }
+	      }
 	      if (!handled_wait) {
-	        /* Multi-fd wait using scheduler-aware rb_thread_fd_select. */
+	        /* Multi-fd select. After the scheduler io_wait fallback above, tv is
+	         * zero and this only polls the complete descriptor set. Without a
+	         * scheduler it performs the normal GVL-releasing wait. */
 	        rb_fdset_t rfds, wfds, efds;
 	        rb_fd_init(&rfds); rb_fd_init(&wfds); rb_fd_init(&efds);
 	        int maxfd = -1;
@@ -1608,9 +1946,8 @@ static void rb_curl_multi_socket_drive(VALUE self, ruby_curl_multi *rbcm, multi_
 	        handled_wait = 1;
 	      }
 	    } else if (count_tracked == 1) {
-#if defined(HAVE_RB_FIBER_SCHEDULER_IO_WAIT) && defined(HAVE_RB_FIBER_SCHEDULER_CURRENT)
       {
-        VALUE scheduler = rb_fiber_scheduler_current();
+        VALUE scheduler = curb_fiber_scheduler_current();
         if (scheduler != Qnil) {
           int scheduler_wait_handled = 0;
           int events = 0;
@@ -1620,11 +1957,9 @@ static void rb_curl_multi_socket_drive(VALUE self, ruby_curl_multi *rbcm, multi_
           double timeout_s = (double)tv.tv_sec + ((double)tv.tv_usec / 1e6);
           VALUE timeout = rb_float_new(timeout_s);
           if (wait_fd < 0) {
-#ifdef HAVE_RB_THREAD_FD_SELECT
-            rb_thread_fd_select(0, NULL, NULL, NULL, &tv);
-#else
-            rb_thread_wait_for(tv);
-#endif
+            /* No pollable fd yet: sleep via the scheduler's kernel_sleep so
+             * sibling fibers keep running while libcurl gets ready. */
+            curb_multi_scheduler_sleep(&tv);
             did_timeout = multi_socket_timer_due(ctx);
             scheduler_wait_handled = 1;
           } else if (!multi_socket_fd_valid_p(wait_fd)) {
@@ -1635,44 +1970,25 @@ static void rb_curl_multi_socket_drive(VALUE self, ruby_curl_multi *rbcm, multi_
             struct io_for_fd_args io_args = { ctx, wait_fd, wait_what };
             int io_state = 0;
             VALUE io = rb_protect(multi_socket_io_for_fd_protected, (VALUE)&io_args, &io_state);
-            if (io_state || NIL_P(io)) {
-              if (io_state) {
-#if CURB_SOCKET_DEBUG
-                VALUE err = rb_errinfo();
-                VALUE msg = rb_obj_as_string(err);
-                curb_debugf("[curb.socket] IO.for_fd failed: %s: %s", rb_obj_classname(err), StringValueCStr(msg));
-#endif
-                rb_set_errinfo(Qnil);
-              }
+            if (io_state) rb_jump_tag(io_state);
+            if (NIL_P(io)) {
               any_ready = 0;
             } else {
-              struct fiber_io_wait_args args = { scheduler, io, INT2NUM(events), timeout };
-              int state = 0;
-              VALUE ready = rb_protect(fiber_io_wait_protected, (VALUE)&args, &state);
-              if (state) {
-#if CURB_SOCKET_DEBUG
-                VALUE err = rb_errinfo();
-                VALUE msg = rb_obj_as_string(err);
-                curb_debugf("[curb.socket] scheduler io_wait failed: %s: %s", rb_obj_classname(err), StringValueCStr(msg));
-#endif
-                rb_set_errinfo(Qnil);
-                any_ready = 0;
-              } else {
-                scheduler_wait_handled = 1;
-                any_ready = (ready != Qfalse && !NIL_P(ready));
-                did_timeout = !any_ready && multi_socket_timer_due(ctx);
-                if (any_ready) {
-                  if (ready == Qtrue) {
-                    ready_flags = multi_socket_cselect_flags_for_curl_poll(wait_what);
-                  } else if (CURB_INTEGER_P(ready)) {
-                    ready_flags = multi_socket_cselect_flags_for_wait_events(NUM2INT(ready));
-                    if (ready_flags == 0) {
-                      any_ready = 0;
-                      did_timeout = multi_socket_timer_due(ctx);
-                    }
-                  } else {
-                    ready_flags = multi_socket_cselect_flags_for_curl_poll(wait_what);
+              VALUE ready = curb_fiber_scheduler_io_wait(scheduler, io, INT2NUM(events), timeout);
+              scheduler_wait_handled = 1;
+              any_ready = (ready != Qfalse && !NIL_P(ready));
+              did_timeout = !any_ready && multi_socket_timer_due(ctx);
+              if (any_ready) {
+                if (ready == Qtrue) {
+                  ready_flags = multi_socket_cselect_flags_for_curl_poll(wait_what);
+                } else if (CURB_INTEGER_P(ready)) {
+                  ready_flags = multi_socket_cselect_flags_for_wait_events(NUM2INT(ready));
+                  if (ready_flags == 0) {
+                    any_ready = 0;
+                    did_timeout = multi_socket_timer_due(ctx);
                   }
+                } else {
+                  ready_flags = multi_socket_cselect_flags_for_curl_poll(wait_what);
                 }
               }
             }
@@ -1680,7 +1996,6 @@ static void rb_curl_multi_socket_drive(VALUE self, ruby_curl_multi *rbcm, multi_
           if (scheduler_wait_handled) handled_wait = 1;
         }
       }
-#endif
 #if defined(HAVE_RB_WAIT_FOR_SINGLE_FD)
       if (!handled_wait && wait_fd >= 0) {
         int ev = multi_socket_wait_events_for_curl_poll(wait_what);
@@ -1724,14 +2039,13 @@ static void rb_curl_multi_socket_drive(VALUE self, ruby_curl_multi *rbcm, multi_
         rb_fd_term(&rfds); rb_fd_term(&wfds); rb_fd_term(&efds);
       }
     } else { /* count_tracked == 0 */
-#ifdef HAVE_RB_THREAD_FD_SELECT
-      rb_thread_fd_select(0, NULL, NULL, NULL, &tv);
-#else
-      rb_thread_wait_for(tv);
-#endif
+      /* No sockets exposed yet (e.g. libcurl's threaded resolver doing DNS):
+       * sleep via the scheduler's kernel_sleep when one is active so sibling
+       * fibers keep running, otherwise a plain thread wait. */
+      curb_multi_scheduler_sleep(&tv);
       /* libcurl can report active work without a socket callback or deadline;
-       * drive the timeout socket after the scheduler-aware sleep so the state
-       * machine does not stall indefinitely. */
+       * drive the timeout socket after the sleep so the state machine does
+       * not stall indefinitely. */
       did_timeout = 1;
     }
 
@@ -1759,7 +2073,13 @@ static void rb_curl_multi_socket_drive(VALUE self, ruby_curl_multi *rbcm, multi_
     rb_curl_multi_read_info(self, rbcm->handle);
     curb_debugf("[curb.socket] processed completions; running=%d", rbcm->running);
     rb_curl_multi_yield_if_given(self, block);
-  }
+    }
+
+    /* Match the legacy perform contract: the block gets a final idle yield,
+     * and work queued from that yield is driven before perform returns. */
+    rb_curl_multi_read_info(self, rbcm->handle);
+    rb_curl_multi_yield_if_given(self, block);
+  } while (rbcm->running);
 }
 
 struct socket_drive_args { VALUE self; ruby_curl_multi *rbcm; multi_socket_ctx *ctx; VALUE block; };
@@ -1769,6 +2089,9 @@ static VALUE ruby_curl_multi_socket_drive_body(VALUE argp) {
   return Qtrue;
 }
 struct socket_cleanup_args { VALUE self; ruby_curl_multi *rbcm; multi_socket_ctx *ctx; };
+static VALUE multi_socket_close_io(VALUE io) {
+  return rb_funcall(io, rb_intern("close"), 0);
+}
 static VALUE ruby_curl_multi_socket_drive_ensure(VALUE argp) {
   struct socket_cleanup_args *c = (struct socket_cleanup_args *)argp;
   if (c->rbcm && c->rbcm->handle) {
@@ -1786,10 +2109,27 @@ static VALUE ruby_curl_multi_socket_drive_ensure(VALUE argp) {
       rb_hash_clear(c->ctx->io_cache);
     }
     c->ctx->io_cache = Qnil;
+    if (!NIL_P(c->ctx->poller_io)) {
+      /* Let Ruby and the scheduler drop the wrapper before the descriptor
+       * goes away. autoclose is off, so this leaves poller_fd open. Keep any
+       * exception already propagating out of the drive loop. */
+      VALUE errinfo = rb_errinfo();
+      int state = 0;
+      rb_protect(multi_socket_close_io, c->ctx->poller_io, &state);
+      rb_set_errinfo(errinfo);
+      c->ctx->poller_io = Qnil;
+    }
+    if (c->ctx->poller_fd >= 0) {
+      close(c->ctx->poller_fd);
+      c->ctx->poller_fd = -1;
+    }
   }
   if (!NIL_P(c->self) && rb_ivar_defined(c->self, id_socket_io_cache_ivar)) {
     rb_funcall(c->self, rb_intern("remove_instance_variable"), 1, ID2SYM(id_socket_io_cache_ivar));
   }
+  if (!NIL_P(c->self) && rb_ivar_defined(c->self, id_socket_poller_io_ivar)) {
+    rb_funcall(c->self, rb_intern("remove_instance_variable"), 1, ID2SYM(id_socket_poller_io_ivar));
+  }
   return Qnil;
 }
 
@@ -1808,7 +2148,17 @@ static VALUE ruby_curl_multi_socket_perform_impl(int argc, VALUE *argv, VALUE se
   ctx.sock_map = st_init_numtable();
   ctx.timeout_deadline_ms = -1;
   ctx.io_cache = rb_hash_new();
+  ctx.poller_fd = -1;
+  ctx.poller_io = Qnil;
   rb_ivar_set(self, id_socket_io_cache_ivar, ctx.io_cache);
+#ifdef CURB_SOCKET_POLLER
+  /* Only fiber-scheduler waits use the poller; thread-level waits keep using
+   * rb_thread_fd_select. If it cannot be created the loop falls back to the
+   * io_select/io_wait paths. */
+  if (curb_fiber_scheduler_current() != Qnil) {
+    ctx.poller_fd = multi_socket_poller_create();
+  }
+#endif
 
   /* install socket/timer callbacks */
   curl_multi_setopt(rbcm->handle, CURLMOPT_SOCKETFUNCTION, multi_socket_cb);
@@ -1822,9 +2172,7 @@ static VALUE ruby_curl_multi_socket_perform_impl(int argc, VALUE *argv, VALUE se
   rb_ensure(ruby_curl_multi_socket_drive_body, (VALUE)&body_args, ruby_curl_multi_socket_drive_ensure, (VALUE)&ensure_args);
 
   /* finalize */
-  rb_curl_multi_read_info(self, rbcm->handle);
-  rb_curl_multi_yield_if_given(self, block);
-  if (cCurlMutiAutoClose == 1) {
+  if (curb_multi_autoclose_enabled()) {
     rbcm->allow_close_during_perform = 1;
     rb_funcall(self, rb_intern("_autoclose"), 0);
     rbcm->allow_close_during_perform = 0;
@@ -1904,17 +2252,19 @@ static void *curb_select_without_gvl(void *args) {
 static VALUE ruby_curl_multi_perform_impl(int argc, VALUE *argv, VALUE self) {
   CURLMcode mcode;
   ruby_curl_multi *rbcm;
+  long timeout_milliseconds;
+  VALUE block = Qnil;
+#ifndef CURB_USE_MULTI_POLL
   int maxfd, rc = -1;
   fd_set fdread, fdwrite, fdexcep;
 #ifdef _WIN32
   fd_set crt_fdread, crt_fdwrite, crt_fdexcep;
 #endif
-  long timeout_milliseconds;
   struct timeval tv = {0, 0};
   struct timeval tv_100ms = {0, 100000};
-  VALUE block = Qnil;
 #if !defined(HAVE_RB_THREAD_FD_SELECT) && (defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL))
   struct _select_set fdset_args;
+#endif
 #endif
 
   rb_scan_args(argc, argv, "0&", &block);
@@ -1925,7 +2275,7 @@ static VALUE ruby_curl_multi_perform_impl(int argc, VALUE *argv, VALUE self) {
     clear_multi_deferred_exception_source_id_if_any(self);
   }
 
-  timeout_milliseconds = cCurlMutiDefaulttimeout;
+  timeout_milliseconds = curb_multi_default_timeout();
 
   // Run curl_multi_perform for the first time to get the ball rolling
   rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
@@ -1959,31 +2309,53 @@ static VALUE ruby_curl_multi_perform_impl(int argc, VALUE *argv, VALUE self) {
         rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
         rb_curl_multi_read_info( self, rbcm->handle );
         rb_curl_multi_yield_if_given(self, block);
-#if defined(HAVE_RB_FIBER_SCHEDULER_CURRENT)
-        if (rb_fiber_scheduler_current() != Qnil) {
-          rb_thread_schedule();
-        }
-#endif
+        /* Yield the fiber so repeated immediate curl timeouts cannot starve
+         * sibling work on this thread. */
+        curb_multi_scheduler_yield();
         continue;
       }
 
-      if (timeout_milliseconds < 0 || timeout_milliseconds > cCurlMutiDefaulttimeout) {
-        timeout_milliseconds = cCurlMutiDefaulttimeout; /* libcurl doesn't know how long to wait, use a default timeout */
+      if (timeout_milliseconds < 0 || timeout_milliseconds > curb_multi_default_timeout()) {
+        timeout_milliseconds = curb_multi_default_timeout(); /* libcurl doesn't know how long to wait, use a default timeout */
                                                         /* or buggy versions libcurl sometimes reports huge timeouts... let's cap it */
       }
 
-#if defined(HAVE_CURL_MULTI_WAIT) && !defined(HAVE_RB_THREAD_FD_SELECT)
+#if defined(CURB_USE_MULTI_POLL)
+      {
+        struct multi_poll_args poll_args;
+        poll_args.handle     = rbcm->handle;
+        poll_args.timeout_ms = timeout_milliseconds > INT_MAX ? INT_MAX : (int)timeout_milliseconds;
+        poll_args.numfds     = 0;
+        poll_args.code       = CURLM_OK;
+        /*
+         * Wait with the GVL released. curl_multi_poll sleeps for the full
+         * timeout even when libcurl has no sockets to watch, so no separate
+         * idle sleep is needed. Pending interrupts are checked when
+         * rb_thread_call_without_gvl returns. Like rb_thread_fd_select, this
+         * wait does not consult the fiber scheduler; perform routes to the
+         * socket-action loop when a scheduler is active.
+         */
+        rb_thread_call_without_gvl(curb_multi_poll_without_gvl, &poll_args,
+                                   curb_multi_poll_ubf, rbcm->handle);
+        if (poll_args.code != CURLM_OK) {
+          raise_curl_multi_error_exception(poll_args.code);
+        }
+        rb_curl_multi_run(self, rbcm->handle, &(rbcm->running));
+        rb_curl_multi_read_info(self, rbcm->handle);
+        rb_curl_multi_yield_if_given(self, block);
+      }
+#elif defined(HAVE_CURL_MULTI_WAIT) && !defined(HAVE_RB_THREAD_FD_SELECT)
       {
         struct wait_args wait_args;
         wait_args.handle     = rbcm->handle;
         wait_args.timeout_ms = timeout_milliseconds;
         wait_args.numfds     = 0;
         /*
-         * When a Fiber scheduler is available (Ruby >= 3.x), rb_thread_fd_select
-         * integrates with it. If we have rb_thread_fd_select available at build
-         * time, we avoid curl_multi_wait entirely (see preprocessor guard above)
-         * and use the fdset branch below. Otherwise, we use curl_multi_wait and
-         * release the GVL so Ruby threads can continue to run.
+         * Wait via curl_multi_wait with the GVL released so other Ruby
+         * threads can continue to run. Like rb_thread_fd_select, this wait
+         * does not consult the fiber scheduler; scheduler-aware waiting is
+         * provided by the socket-action loop, which perform routes to when a
+         * scheduler is active (see ruby_curl_multi_perform).
          */
         CURLMcode wait_rc;
 #if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
@@ -1997,13 +2369,7 @@ static VALUE ruby_curl_multi_perform_impl(int argc, VALUE *argv, VALUE self) {
           raise_curl_multi_error_exception(wait_rc);
         }
         if (wait_args.numfds == 0) {
-#ifdef HAVE_RB_THREAD_FD_SELECT
-          struct timeval tv_sleep = tv_100ms;
-          /* Sleep in a scheduler-aware way. */
-          rb_thread_fd_select(0, NULL, NULL, NULL, &tv_sleep);
-#else
-          rb_thread_wait_for(tv_100ms);
-#endif
+          curb_multi_scheduler_sleep(&tv_100ms);
         }
         /* Process pending transfers after waiting */
         rb_curl_multi_run(self, rbcm->handle, &(rbcm->running));
@@ -2012,8 +2378,10 @@ static VALUE ruby_curl_multi_perform_impl(int argc, VALUE *argv, VALUE self) {
       }
 #else
 
-      tv.tv_sec  = 0; /* never wait longer than 1 second */
-      tv.tv_usec = (int)(timeout_milliseconds * 1000); /* XXX: int is the right type for OSX, what about linux? */
+      /* Split into seconds and microseconds: a raw select() rejects a
+       * tv_usec of 1000000 or more, which default_timeout > 1000 produced. */
+      tv.tv_sec  = timeout_milliseconds / 1000;
+      tv.tv_usec = (timeout_milliseconds % 1000) * 1000;
 
       FD_ZERO(&fdread);
       FD_ZERO(&fdwrite);
@@ -2027,12 +2395,7 @@ static VALUE ruby_curl_multi_perform_impl(int argc, VALUE *argv, VALUE self) {
 
       if (maxfd == -1) {
         /* libcurl recommends sleeping for 100ms */
-#ifdef HAVE_RB_THREAD_FD_SELECT
-        struct timeval tv_sleep = tv_100ms;
-        rb_thread_fd_select(0, NULL, NULL, NULL, &tv_sleep);
-#else
-        rb_thread_wait_for(tv_100ms);
-#endif
+        curb_multi_scheduler_sleep(&tv_100ms);
         rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
         rb_curl_multi_read_info( self, rbcm->handle );
         rb_curl_multi_yield_if_given(self, block);
@@ -2055,7 +2418,10 @@ static VALUE ruby_curl_multi_perform_impl(int argc, VALUE *argv, VALUE self) {
 #endif
 
 #ifdef HAVE_RB_THREAD_FD_SELECT
-      /* Prefer scheduler-aware waiting when available. Build rb_fdset_t sets. */
+      /* Wait with the GVL released. Note rb_thread_fd_select does not consult
+       * the fiber scheduler — under a scheduler, perform routes to the
+       * socket-action loop instead (see ruby_curl_multi_perform). Build
+       * rb_fdset_t sets. */
       {
         rb_fdset_t rfds, wfds, efds;
         rb_fd_init(&rfds);
@@ -2115,7 +2481,7 @@ static VALUE ruby_curl_multi_perform_impl(int argc, VALUE *argv, VALUE self) {
     rb_curl_multi_yield_if_given(self, block);
   } while( rbcm->running );
 
-  if (cCurlMutiAutoClose  == 1) {
+  if (curb_multi_autoclose_enabled()) {
     rbcm->allow_close_during_perform = 1;
     rb_funcall(self, rb_intern("_autoclose"), 0);
     rbcm->allow_close_during_perform = 0;
@@ -2167,9 +2533,34 @@ static VALUE ruby_curl_multi_with_perform_guard(int argc, VALUE *argv, VALUE sel
 }
 
 VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
+#if defined(HAVE_CURL_MULTI_SOCKET_ACTION) && defined(HAVE_CURLMOPT_SOCKETFUNCTION) && defined(HAVE_CURLMOPT_TIMERFUNCTION) && defined(HAVE_RB_THREAD_FD_SELECT) && !defined(_WIN32)
+  /*
+   * The legacy fdset loop waits with rb_thread_fd_select, which releases the
+   * GVL but never consults the fiber scheduler, stalling every other fiber on
+   * this thread for the duration of the transfers. When the calling fiber
+   * runs under a fiber scheduler, use the socket-action drive loop, which
+   * waits through the scheduler's io_wait/io_select/kernel_sleep hooks.
+   */
+  if (curb_fiber_scheduler_current() != Qnil) {
+    return ruby_curl_multi_with_perform_guard(argc, argv, self, ruby_curl_multi_socket_perform_impl);
+  }
+#endif
   return ruby_curl_multi_with_perform_guard(argc, argv, self, ruby_curl_multi_perform_impl);
 }
 
+/*
+ * Name of the kernel event queue the socket-action loop waits on under a
+ * fiber scheduler ("epoll" or "kqueue"), or nil when this build has none.
+ */
+static VALUE ruby_curl_multi_socket_poller(VALUE klass) {
+  (void)klass;
+#ifdef CURB_SOCKET_POLLER
+  return rb_str_new_cstr(CURB_SOCKET_POLLER_NAME);
+#else
+  return Qnil;
+#endif
+}
+
 #if defined(HAVE_CURL_MULTI_SOCKET_ACTION) && defined(HAVE_CURLMOPT_SOCKETFUNCTION) && defined(HAVE_CURLMOPT_TIMERFUNCTION) && defined(HAVE_RB_THREAD_FD_SELECT) && !defined(_WIN32)
 VALUE ruby_curl_multi_socket_perform(int argc, VALUE *argv, VALUE self) {
   return ruby_curl_multi_with_perform_guard(argc, argv, self, ruby_curl_multi_socket_perform_impl);
@@ -2233,10 +2624,31 @@ static void curl_multi_mark(void *ptr) {
 /* =================== INIT LIB =====================*/
 void init_curb_multi() {
   idCall = rb_intern("call");
+  cRubyFiber = rb_const_get(rb_cObject, rb_intern("Fiber"));
+  rb_global_variable(&cRubyFiber);
+  cRubyRactor = Qnil;
+  id_ractor_current = rb_intern("current");
+  id_ractor_aref = rb_intern("[]");
+  id_ractor_aset = rb_intern("[]=");
+  id_ractor_default_timeout_key = rb_intern("__curb_multi_default_timeout");
+  id_ractor_autoclose_key = rb_intern("__curb_multi_autoclose");
+  if (rb_const_defined(rb_cObject, rb_intern("Ractor"))) {
+    VALUE ractor = rb_const_get(rb_cObject, rb_intern("Ractor"));
+    VALUE current = rb_funcall(ractor, id_ractor_current, 0);
+    if (rb_respond_to(current, id_ractor_aref) && rb_respond_to(current, id_ractor_aset)) {
+      cRubyRactor = ractor;
+    }
+  }
+  rb_global_variable(&cRubyRactor);
+  id_fiber_blocking_p = rb_intern("blocking?");
+  id_fiber_scheduler = rb_intern("scheduler");
+  id_kernel_sleep = rb_intern("kernel_sleep");
+  id_io_wait = rb_intern("io_wait");
   id_deferred_exception_ivar = rb_intern("@__curb_deferred_exception");
   id_deferred_exception_source_id_ivar = rb_intern("@__curb_deferred_exception_source_id");
   id_native_safety_signatures_ivar = rb_intern("@__curb_native_safety_signatures");
   id_socket_io_cache_ivar = rb_intern("@__curb_socket_io_cache");
+  id_socket_poller_io_ivar = rb_intern("@__curb_socket_poller_io");
   cCurlMulti = rb_define_class_under(mCurl, "Multi", rb_cObject);
 
   rb_define_alloc_func(cCurlMulti, ruby_curl_multi_alloc);
@@ -2254,14 +2666,16 @@ void init_curb_multi() {
   rb_define_method(cCurlMulti, "_add", ruby_curl_multi_add, 1);
   rb_define_method(cCurlMulti, "_remove", ruby_curl_multi_remove, 1);
   /*
-   * The legacy fdset loop is the stable default. The newer socket-action path
-   * is kept in-tree, but it has shown scheduler regressions for one-handle
-   * multi usage (for example Curl::Easy#perform under Async).
+   * perform uses the legacy fdset loop by default, but routes to the
+   * socket-action drive loop when the calling fiber runs under a fiber
+   * scheduler so sibling fibers keep running during transfers. The
+   * socket-action path is also exposed directly as _socket_perform.
    */
   rb_define_method(cCurlMulti, "perform", ruby_curl_multi_perform, -1);
 #if defined(HAVE_CURL_MULTI_SOCKET_ACTION) && defined(HAVE_CURLMOPT_SOCKETFUNCTION) && defined(HAVE_CURLMOPT_TIMERFUNCTION) && defined(HAVE_RB_THREAD_FD_SELECT) && !defined(_WIN32)
   rb_define_private_method(cCurlMulti, "_socket_perform", ruby_curl_multi_socket_perform, -1);
 #endif
+  rb_define_private_method(rb_singleton_class(cCurlMulti), "_socket_poller", ruby_curl_multi_socket_poller, 0);
   rb_define_method(cCurlMulti, "_close", ruby_curl_multi_close, 0);
   rb_define_private_method(cCurlMulti, "_mark_closed", ruby_curl_multi_mark_closed, 0);
 }