[ViewVC] Diff of: cvs/libev/ev

Comparing libev/ev_linuxaio.c (file contents):
Revision 1.9 by root, Sat Jun 22 22:29:38 2019 UTC vs.
Revision 1.18 by root, Mon Jun 24 04:54:08 2019 UTC

  * and other provisions required by the GPL. If you do not delete the
  * provisions above, a recipient may use your version of this file under
  * either the BSD or the GPL.
  */
+#define EPOLL_FALLBACK 1
 #include <sys/time.h> /* actually linux/time.h, but we must assume they are compatible */
 #include <poll.h>
 #include <linux/aio_abi.h>
+#if EPOLL_FALLBACK
+# include <sys/epoll.h>
+#endif
 /* we try to fill 4kB pages exactly.
  * the ring buffer header is 32 bytes, every io event is 32 bytes.
  * the kernel takes the io event number, doubles it, adds 2, adds the ring buffer.
  * therefore the calculation below will use "exactly" 4kB for the ring buffer
 linuxaio_modify (EV_P_ int fd, int oev, int nev)
 {
   array_needsize (ANIOCBP, linuxaio_iocbps, linuxaio_iocbpmax, fd + 1, linuxaio_array_needsize_iocbp);
   struct aniocb *iocb = linuxaio_iocbps [fd];
+#if EPOLL_FALLBACK
+  if (iocb->io.aio_reqprio < 0)
+    {
+      epoll_ctl (backend_fd, EPOLL_CTL_DEL, fd, 0);
+      iocb->io.aio_reqprio = 0;
+    }
+#endif
   if (iocb->io.aio_buf)
     ev_io_cancel (linuxaio_ctx, &iocb->io, (struct io_event *)0); /* always returns an error relevant kernels */
   if (nev)
     {
       linuxaio_iocbps [fd]->io.aio_buf = 0;
       anfds [fd].events = 0;
       fd_change (EV_A_ fd, 0);
       /* feed events, we do not expect or handle POLLNVAL */
-      if (ecb_expect_false (res & POLLNVAL))
+      if (expect_false (res & POLLNVAL))
         fd_kill (EV_A_ fd);
       else
         fd_event (
           EV_A_
           fd,
 static int
 linuxaio_get_events_from_ring (EV_P)
 {
   struct aio_ring *ring = (struct aio_ring *)linuxaio_ctx;
-  unsigned head = ring->head;
+  /* the kernel reads and writes both of these variables, */
+  /* as a C extension, we assume that volatile use here */
+  /* both makes reads atomic and once-only */
+  unsigned head = *(volatile unsigned *)&ring->head;
   unsigned tail = *(volatile unsigned *)&ring->tail;
   if (head == tail)
     return 0;
   /* bail out if the ring buffer doesn't match the expected layout */
-  if (ecb_expect_false (ring->magic != AIO_RING_MAGIC)
+  if (expect_false (ring->magic != AIO_RING_MAGIC)
-                        || ring->incompat_features != AIO_RING_INCOMPAT_FEATURES
+                    || ring->incompat_features != AIO_RING_INCOMPAT_FEATURES
-                        || ring->header_length != sizeof (struct aio_ring)) /* TODO: or use it to find io_event[0]? */
+                    || ring->header_length != sizeof (struct aio_ring)) /* TODO: or use it to find io_event[0]? */
     return 0;
+  /* make sure the events up to tail are visible */
   ECB_MEMORY_FENCE_ACQUIRE;
   /* parse all available events, but only once, to avoid starvation */
   if (tail > head) /* normal case around */
     linuxaio_parse_events (EV_A_ ring->io_events + head, tail - head);
     {
       linuxaio_parse_events (EV_A_ ring->io_events + head, ring->nr - head);
       linuxaio_parse_events (EV_A_ ring->io_events, tail);
     }
-  ring->head = tail;
+  /* TODO: we only need a compiler barrier here, not a read fence */
+  ECB_MEMORY_FENCE_RELEASE;
+  /* as an extension to C, we hope that the volatile will make this atomic and once-only */
+  *(volatile unsigned *)&ring->head = tail;
+  /* make sure kernel can see our new head value - probably not required */
+  ECB_MEMORY_FENCE_RELEASE;
   return 1;
 }
 /* read at least one event from kernel, or timeout */
 inline_size
 void
 linuxaio_get_events (EV_P_ ev_tstamp timeout)
 {
   struct timespec ts;
-  struct io_event ioev;
+  struct io_event ioev[1];
   int res;
   if (linuxaio_get_events_from_ring (EV_A))
     return;
   /* if the ring buffer changes layout, but so be it */
   ts.tv_sec  = (long)timeout;
   ts.tv_nsec = (long)((timeout - ts.tv_sec) * 1e9);
-  res = ev_io_getevents (linuxaio_ctx, 1, 1, &ioev, &ts);
+  res = ev_io_getevents (linuxaio_ctx, 1, sizeof (ioev) / sizeof (ioev [0]), ioev, &ts);
   if (res < 0)
+    if (errno == EINTR)
+      /* ignored */;
+    else
-    ev_syserr ("(libev) linuxaio io_getevents");
+      ev_syserr ("(libev) linuxaio io_getevents");
   else if (res)
     {
       /* at least one event received, handle it and any remaining ones in the ring buffer */
-      linuxaio_parse_events (EV_A_ &ioev, 1);
+      linuxaio_parse_events (EV_A_ ioev, res);
       linuxaio_get_events_from_ring (EV_A);
     }
 }
+#if EPOLL_FALLBACK
+static void
+linuxaio_rearm_epoll (EV_P_ struct iocb *iocb, int op)
+{
+  struct epoll_event eev;
+  eev.events = EPOLLONESHOT;
+  if (iocb->aio_buf & POLLIN ) eev.events |= EPOLLIN ;
+  if (iocb->aio_buf & POLLOUT) eev.events |= EPOLLOUT;
+  eev.data.fd = iocb->aio_fildes;
+  if (epoll_ctl (backend_fd, op, iocb->aio_fildes, &eev) < 0)
+    ev_syserr ("(libeio) linuxaio epoll_ctl");
+}
+#endif
 static void
 linuxaio_poll (EV_P_ ev_tstamp timeout)
 {
   int submitted;
   /* which allows us to pinpoint the errornous iocb */
   for (submitted = 0; submitted < linuxaio_submitcnt; )
     {
       int res = ev_io_submit (linuxaio_ctx, linuxaio_submitcnt - submitted, linuxaio_submits + submitted);
-      if (ecb_expect_false (res < 0))
+      if (expect_false (res < 0))
         if (errno == EAGAIN)
           {
             /* This happens when the ring buffer is full, at least. I assume this means
              * that the event was queued synchronously during io_submit, and thus
-             * the buffer overflowd.
+             * the buffer overflowed.
-             * In this case, we just try next loop iteration.
+             * In this case, we just try in next loop iteration.
              * This should not result in a few fds taking priority, as the interface
              * is one-shot, and we submit iocb's in a round-robin fashion.
              */
             memmove (linuxaio_submits, linuxaio_submits + submitted, (linuxaio_submitcnt - submitted) * sizeof (*linuxaio_submits));
             linuxaio_submitcnt -= submitted;
             timeout = 0;
             break;
           }
+#if EPOLL_FALLBACK
+        else if (errno == EINVAL)
+          {
+            /* This happens for unsupported fds, officially, but in my testing,
+             * also randomly happens for supported fds. We fall back to good old
+             * poll() here, under the assumption that this is a very rare case.
+             * See https://lore.kernel.org/patchwork/patch/1047453/ for evidence
+             * that the problem is known, but ignored.
+             */
+            struct iocb *iocb = linuxaio_submits [submitted];
+            res = 1; /* skip this iocb */
+            linuxaio_rearm_epoll (EV_A_ iocb, EPOLL_CTL_ADD);
+            iocb->aio_reqprio = -1; /* mark iocb as epoll */
+          }
+#endif
         else
           ev_syserr ("(libev) linuxaio io_submit");
       submitted += res;
     }
   /* second phase: fetch and parse events */
   linuxaio_get_events (EV_A_ timeout);
 }
+#if EPOLL_FALLBACK
+static void
+linuxaio_epoll_cb (EV_P_ struct ev_io *w, int revents)
+{
+  struct epoll_event events[16];
+  for (;;)
+    {
+      int idx;
+      int res = epoll_wait (backend_fd, events, sizeof (events) / sizeof (events [0]), 0);
+      if (expect_false (res < 0))
+        ev_syserr ("(libev) linuxaio epoll_wait");
+      else if (!res)
+        break;
+      for (idx = res; idx--; )
+        {
+          int      fd = events [idx].data.fd;
+          uint32_t ev = events [idx].events;
+          assert (("libev: iocb fd must be in-bounds", fd >= 0 && fd < anfdmax));
+          linuxaio_rearm_epoll (EV_A_ &linuxaio_iocbps [fd]->io, EPOLL_CTL_MOD);
+          fd_event (EV_A_ fd,
+            (ev & (EPOLLOUT | EPOLLERR | EPOLLHUP) ? EV_WRITE : 0)
+            | (ev & (EPOLLIN  | EPOLLERR | EPOLLHUP) ? EV_READ  : 0));
+        }
+      if (res < sizeof (events) / sizeof (events [0]))
+        break;
+    }
+}
+#endif
 inline_size
 int
 linuxaio_init (EV_P_ int flags)
 {
   /* would be great to have a nice test for IOCB_CMD_POLL instead */
   /* also: test some semi-common fd types, such as files and ttys in recommended_backends */
-  if (ev_linux_version () < 0x041200) /* 4.18 introduced IOCB_CMD_POLL */
+#if EPOLL_FALLBACK
+  /* 4.19 made epoll work */
+  if (ev_linux_version () < 0x041300)
     return 0;
+#else
+  /* 4.18 introduced IOCB_CMD_POLL */
+  if (ev_linux_version () < 0x041200)
+    return 0;
+#endif
   linuxaio_ctx = 0;
   if (ev_io_setup (EV_LINUXAIO_DEPTH, &linuxaio_ctx) < 0)
     return 0;
+#if EPOLL_FALLBACK
+  backend_fd = ev_epoll_create ();
+  if (backend_fd < 0)
+    {
+      ev_io_destroy (linuxaio_ctx);
+      return 0;
+    }
+  ev_io_init  (EV_A_ &linuxaio_epoll_w, linuxaio_epoll_cb, backend_fd, EV_READ);
+  ev_io_start (EV_A_ &linuxaio_epoll_w);
+  ev_unref (EV_A); /* watcher should not keep loop alive */
+#endif
   backend_modify  = linuxaio_modify;
   backend_poll    = linuxaio_poll;
   linuxaio_iocbpmax = 0;
   linuxaio_iocbps = 0;
 inline_size
 void
 linuxaio_destroy (EV_P)
 {
+#if EPOLL_FALLBACK
+  close (backend_fd);
+#endif
   linuxaio_free_iocbp (EV_A);
   ev_io_destroy (linuxaio_ctx);
 }
 inline_size
   linuxaio_ctx = 0;
   while (ev_io_setup (EV_LINUXAIO_DEPTH, &linuxaio_ctx) < 0)
     ev_syserr ("(libev) linuxaio io_setup");
+#if EPOLL_FALLBACK
+  while ((backend_fd = ev_epoll_create ()) < 0)
+   ev_syserr ("(libev) linuxaio epoll_create");
+  ev_io_stop  (EV_A_ &linuxaio_epoll_w);
+  ev_io_init  (EV_A_ &linuxaio_epoll_w, linuxaio_epoll_cb, backend_fd, EV_READ);
+  ev_io_start (EV_A_ &linuxaio_epoll_w);
+#endif
   fd_rearm_all (EV_A);
 }

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing libev/ev_linuxaio.c (file contents): Revision 1.9 by root, Sat Jun 22 22:29:38 2019 UTC vs. Revision 1.18 by root, Mon Jun 24 04:54:08 2019 UTC

Diff Legend

Comparing libev/ev_linuxaio.c (file contents):
Revision 1.9 by root, Sat Jun 22 22:29:38 2019 UTC vs.
Revision 1.18 by root, Mon Jun 24 04:54:08 2019 UTC