[ViewVC] Diff of: cvs/libev/ev

Comparing libev/ev_linuxaio.c (file contents):
Revision 1.25 by root, Tue Jun 25 04:52:30 2019 UTC vs.
Revision 1.45 by root, Thu Jul 4 23:59:36 2019 UTC

  *    POLLOUT|POLLIN, but polling for POLLIN fails. just great,
  *    so we have to fall back to something else (hello, epoll),
  *    but at least the fallback can be slow, because these are
  *    exceptional cases, right?
  * d) hmm, you have to tell the kernel the maximum number of watchers
- *    you want to queue when initialiasing the aio context. but of
+ *    you want to queue when initialising the aio context. but of
  *    course the real limit is magically calculated in the kernel, and
  *    is often higher then we asked for. so we just have to destroy
  *    the aio context and re-create it a bit larger if we hit the limit.
  *    (starts to remind you of epoll? well, it's a bit more deterministic
  *    and less gambling, but still ugly as hell).
  *    limit. or the kernel simply doesn't want to handle your watchers.
  *    what the fuck do we do then? you guessed it, in the middle
  *    of event handling we have to switch to 100% epoll polling. and
  *    that better is as fast as normal epoll polling, so you practically
  *    have to use the normal epoll backend with all its quirks.
- * f) end result of this trainwreck: it inherits all the disadvantages
+ * f) end result of this train wreck: it inherits all the disadvantages
  *    from epoll, while adding a number on its own. why even bother to use
  *    it? because if conditions are right and your fds are supported and you
  *    don't hit a limit, this backend is actually faster, doesn't gamble with
  *    your fds, batches watchers and events and doesn't require costly state
  *    recreates. well, until it does.
  * g) all of this makes this backend use almost twice as much code as epoll.
- *    which in turn uses twice as much code as poll. and thats not counting
+ *    which in turn uses twice as much code as poll. and that#s not counting
  *    the fact that this backend also depends on the epoll backend, making
  *    it three times as much code as poll, or kqueue.
  * h) bleah. why can't linux just do kqueue. sure kqueue is ugly, but by now
- *    it's clear that whwetaver linux does is far, far far worse.
+ *    it's clear that whatever linux comes up with is far, far, far worse.
  */
 #include <sys/time.h> /* actually linux/time.h, but we must assume they are compatible */
 #include <poll.h>
 #include <linux/aio_abi.h>
  * not only is this totally undocumented, not even the source code
  * can tell you what the future semantics of compat_features and
  * incompat_features are, or what header_length actually is for.
  */
 #define AIO_RING_MAGIC                  0xa10a10a1
-#define AIO_RING_INCOMPAT_FEATURES      0
+#define EV_AIO_RING_INCOMPAT_FEATURES   0
 struct aio_ring
 {
   unsigned id;    /* kernel internal index number */
   unsigned nr;    /* number of io_events */
   unsigned head;  /* Written to by userland or by kernel. */
 inline_size
 int
 evsys_io_setup (unsigned nr_events, aio_context_t *ctx_idp)
 {
-  return syscall (SYS_io_setup, nr_events, ctx_idp);
+  return ev_syscall2 (SYS_io_setup, nr_events, ctx_idp);
 }
 inline_size
 int
 evsys_io_destroy (aio_context_t ctx_id)
 {
-  return syscall (SYS_io_destroy, ctx_id);
+  return ev_syscall1 (SYS_io_destroy, ctx_id);
 }
 inline_size
 int
 evsys_io_submit (aio_context_t ctx_id, long nr, struct iocb *cbp[])
 {
-  return syscall (SYS_io_submit, ctx_id, nr, cbp);
+  return ev_syscall3 (SYS_io_submit, ctx_id, nr, cbp);
 }
 inline_size
 int
 evsys_io_cancel (aio_context_t ctx_id, struct iocb *cbp, struct io_event *result)
 {
-  return syscall (SYS_io_cancel, ctx_id, cbp, result);
+  return ev_syscall3 (SYS_io_cancel, ctx_id, cbp, result);
 }
 inline_size
 int
 evsys_io_getevents (aio_context_t ctx_id, long min_nr, long nr, struct io_event *events, struct timespec *timeout)
 {
-  return syscall (SYS_io_getevents, ctx_id, min_nr, nr, events, timeout);
+  return ev_syscall5 (SYS_io_getevents, ctx_id, min_nr, nr, events, timeout);
 }
 /*****************************************************************************/
 /* actual backed implementation */
     requests = requests / one_page * one_page + first_page;
   return requests;
 }
-/* we use out own wrapper structure in acse we ever want to do something "clever" */
+/* we use out own wrapper structure in case we ever want to do something "clever" */
 typedef struct aniocb
 {
   struct iocb io;
   /*int inuse;*/
 } *ANIOCBP;
 void
 linuxaio_array_needsize_iocbp (ANIOCBP *base, int offset, int count)
 {
   while (count--)
     {
-      /* TODO: quite the overhead to allocate every iocb separately, maybe use our own alocator? */
+      /* TODO: quite the overhead to allocate every iocb separately, maybe use our own allocator? */
       ANIOCBP iocb = (ANIOCBP)ev_malloc (sizeof (*iocb));
       /* full zero initialise is probably not required at the moment, but
        * this is not well documented, so we better do it.
        */
 linuxaio_modify (EV_P_ int fd, int oev, int nev)
 {
   array_needsize (ANIOCBP, linuxaio_iocbps, linuxaio_iocbpmax, fd + 1, linuxaio_array_needsize_iocbp);
   ANIOCBP iocb = linuxaio_iocbps [fd];
-  if (iocb->io.aio_reqprio < 0)
+  if (ecb_expect_false (iocb->io.aio_reqprio < 0))
     {
       /* we handed this fd over to epoll, so undo this first */
-      /* we do it manually becvause the optimisations on epoll_modfy won't do us any good */
+      /* we do it manually because the optimisations on epoll_modify won't do us any good */
       epoll_ctl (backend_fd, EPOLL_CTL_DEL, fd, 0);
+      anfds [fd].emask = 0;
       iocb->io.aio_reqprio = 0;
     }
+  if (ecb_expect_false (iocb->io.aio_buf))
+    {
+      /* iocb active, so cancel it first before resubmit */
+      for (;;)
+        {
+          /* on all relevant kernels, io_cancel fails with EINPROGRESS on "success" */
+          if (ecb_expect_false (evsys_io_cancel (linuxaio_ctx, &iocb->io, (struct io_event *)0) == 0))
+            break;
+          if (ecb_expect_true (errno == EINPROGRESS))
+            break;
+          /* the EINPROGRESS test is for nicer error message. clumsy. */
+          assert (("libev: linuxaio unexpected io_cancel failed", errno != EINPROGRESS && errno != EINTR));
+       }
+    }
-  if (iocb->io.aio_buf)
+  iocb->io.aio_buf =
-    /* io_cancel always returns some error on relevant kernels, but works */
+      (nev & EV_READ ? POLLIN : 0)
-    evsys_io_cancel (linuxaio_ctx, &iocb->io, (struct io_event *)0);
+      | (nev & EV_WRITE ? POLLOUT : 0);
   if (nev)
     {
-      iocb->io.aio_buf =
-          (nev & EV_READ ? POLLIN : 0)
-          | (nev & EV_WRITE ? POLLOUT : 0);
       /* queue iocb up for io_submit */
       /* this assumes we only ever get one call per fd per loop iteration */
       ++linuxaio_submitcnt;
       array_needsize (struct iocb *, linuxaio_submits, linuxaio_submitmax, linuxaio_submitcnt, array_needsize_noinit);
       linuxaio_submits [linuxaio_submitcnt - 1] = &iocb->io;
 linuxaio_epoll_cb (EV_P_ struct ev_io *w, int revents)
 {
   epoll_poll (EV_A_ 0);
 }
-static void
+inline_speed
+void
 linuxaio_fd_rearm (EV_P_ int fd)
 {
   anfds [fd].events = 0;
   linuxaio_iocbps [fd]->io.aio_buf = 0;
   fd_change (EV_A_ fd, EV_ANFD_REIFY);
         fd,
         (res & (POLLOUT | POLLERR | POLLHUP) ? EV_WRITE : 0)
         | (res & (POLLIN | POLLERR | POLLHUP) ? EV_READ : 0)
       );
-      /* linux aio is oneshot: rearm fd. TODO: this does more work than needed */
+      /* linux aio is oneshot: rearm fd. TODO: this does more work than strictly needed */
       linuxaio_fd_rearm (EV_A_ fd);
       --nr;
       ++ev;
     }
 }
-/* get any events from ringbuffer, return true if any were handled */
+/* get any events from ring buffer, return true if any were handled */
 static int
 linuxaio_get_events_from_ring (EV_P)
 {
   struct aio_ring *ring = (struct aio_ring *)linuxaio_ctx;
+  unsigned head, tail;
   /* 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;
+  head = *(volatile unsigned *)&ring->head;
+  ECB_MEMORY_FENCE_ACQUIRE;
-  unsigned tail = *(volatile unsigned *)&ring->tail;
+  tail = *(volatile unsigned *)&ring->tail;
   if (head == tail)
     return 0;
-  /* bail out if the ring buffer doesn't match the expected layout */
-  if (expect_false (ring->magic != AIO_RING_MAGIC)
-                    || ring->incompat_features != AIO_RING_INCOMPAT_FEATURES
-                    || 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 */
+  if (ecb_expect_true (tail > head)) /* normal case around */
     linuxaio_parse_events (EV_A_ ring->io_events + head, tail - head);
   else /* wrapped around */
     {
       linuxaio_parse_events (EV_A_ ring->io_events + head, ring->nr - head);
       linuxaio_parse_events (EV_A_ ring->io_events, tail);
     }
-  ECB_MEMORY_FENCE_RELAXED;
+  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;
+}
+inline_size
+int
+linuxaio_ringbuf_valid (EV_P)
+{
+  struct aio_ring *ring = (struct aio_ring *)linuxaio_ctx;
+  return ecb_expect_true (ring->magic == AIO_RING_MAGIC)
+                      && ring->incompat_features == EV_AIO_RING_INCOMPAT_FEATURES
+                      && ring->header_length == sizeof (struct aio_ring); /* TODO: or use it to find io_event[0]? */
 }
 /* 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[1];
+  struct io_event ioev[8]; /* 256 octet stack space */
-  int res;
+  int want = 1; /* how many events to request */
+  int ringbuf_valid = linuxaio_ringbuf_valid (EV_A);
+  if (ecb_expect_true (ringbuf_valid))
+    {
+      /* if the ring buffer has any events, we don't wait or call the kernel at all */
-  if (linuxaio_get_events_from_ring (EV_A))
+      if (linuxaio_get_events_from_ring (EV_A))
-    return;
+        return;
-  /* no events, so wait for at least one, then poll ring buffer again */
+      /* if the ring buffer is empty, and we don't have a timeout, then don't call the kernel */
-  /* this degrades to one event per loop iteration */
+      if (!timeout)
-  /* if the ring buffer changes layout, but so be it */
+        return;
+    }
+  else
+    /* no ringbuffer, request slightly larger batch */
+    want = sizeof (ioev) / sizeof (ioev [0]);
+  /* no events, so wait for some
+   * for fairness reasons, we do this in a loop, to fetch all events
+   */
+  for (;;)
+    {
+      int res;
-  EV_RELEASE_CB;
+      EV_RELEASE_CB;
-  ts.tv_sec  = (long)timeout;
+      EV_TS_SET (ts, timeout);
-  ts.tv_nsec = (long)((timeout - ts.tv_sec) * 1e9);
+      res = evsys_io_getevents (linuxaio_ctx, 1, want, ioev, &ts);
-  res = evsys_io_getevents (linuxaio_ctx, 1, sizeof (ioev) / sizeof (ioev [0]), ioev, &ts);
-  EV_ACQUIRE_CB;
+      EV_ACQUIRE_CB;
-  if (res < 0)
+      if (res < 0)
-    if (errno == EINTR)
+        if (errno == EINTR)
-      /* ignored */;
+          /* ignored, retry */;
-    else
+        else
-      ev_syserr ("(libev) linuxaio io_getevents");
+          ev_syserr ("(libev) linuxaio io_getevents");
-  else if (res)
+      else if (res)
-    {
+        {
-      /* at least one event received, handle it and any remaining ones in the ring buffer */
+          /* at least one event available, handle them */
-      linuxaio_parse_events (EV_A_ ioev, res);
+          linuxaio_parse_events (EV_A_ ioev, res);
+          if (ecb_expect_true (ringbuf_valid))
+            {
+              /* if we have a ring buffer, handle any remaining events in it */
-      linuxaio_get_events_from_ring (EV_A);
+              linuxaio_get_events_from_ring (EV_A);
-    }
-}
-static int
+              /* at this point, we should have handled all outstanding events */
+              break;
+            }
+          else if (res < want)
+            /* otherwise, if there were fewere events than we wanted, we assume there are no more */
+            break;
+        }
+      else
+        break; /* no events from the kernel, we are done */
+      timeout = 0; /* only wait in the first iteration */
+    }
+}
+inline_size
+int
 linuxaio_io_setup (EV_P)
 {
   linuxaio_ctx = 0;
   return evsys_io_setup (linuxaio_nr_events (EV_A), &linuxaio_ctx);
 }
   /* first phase: submit new iocbs */
   /* io_submit might return less than the requested number of iocbs */
   /* this is, afaics, only because of errors, but we go by the book and use a loop, */
-  /* which allows us to pinpoint the errornous iocb */
+  /* which allows us to pinpoint the erroneous iocb */
   for (submitted = 0; submitted < linuxaio_submitcnt; )
     {
       int res = evsys_io_submit (linuxaio_ctx, linuxaio_submitcnt - submitted, linuxaio_submits + submitted);
-      if (expect_false (res < 0))
+      if (ecb_expect_false (res < 0))
         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.
             res = 1; /* skip this iocb - another iocb, another chance */
           }
         else if (errno == EAGAIN)
           {
             /* This happens when the ring buffer is full, or some other shit we
-             * dont' know and isn't documented. Most likely because we have too
+             * don't know and isn't documented. Most likely because we have too
              * many requests and linux aio can't be assed to handle them.
              * In this case, we try to allocate a larger ring buffer, freeing
              * ours first. This might fail, in which case we have to fall back to 100%
              * epoll.
              * God, how I hate linux not getting its act together. Ever.
             }
             ++linuxaio_iteration;
             if (linuxaio_io_setup (EV_A) < 0)
               {
+                /* TODO: rearm all and recreate epoll backend from scratch */
+                /* TODO: might be more prudent? */
                 /* to bad, we can't get a new aio context, go 100% epoll */
                 linuxaio_free_iocbp (EV_A);
                 ev_io_stop (EV_A_ &linuxaio_epoll_w);
                 ev_ref (EV_A);
                 linuxaio_ctx = 0;
+                backend        = EVBACKEND_EPOLL;
                 backend_modify = epoll_modify;
                 backend_poll   = epoll_poll;
               }
             timeout = 0;
             /* it's easiest to handle this mess in another iteration */
             return;
           }
         else if (errno == EBADF)
           {
+            assert (("libev: event loop rejected bad fd", errno != EBADF));
             fd_kill (EV_A_ linuxaio_submits [submitted]->aio_fildes);
             res = 1; /* skip this iocb */
           }
+        else if (errno == EINTR) /* not seen in reality, not documented */
+          res = 0; /* silently ignore and retry */
         else
+          {
-          ev_syserr ("(libev) linuxaio io_submit");
+            ev_syserr ("(libev) linuxaio io_submit");
+            res = 0;
+          }
       submitted += res;
     }
   linuxaio_submitcnt = 0;
 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 */
-  /* 4.18 introduced IOCB_CMD_POLL, 4.19 made epoll work */
+  /* 4.18 introduced IOCB_CMD_POLL, 4.19 made epoll work, and we need that */
   if (ev_linux_version () < 0x041300)
     return 0;
   if (!epoll_init (EV_A_ 0))
     return 0;
   ev_io_init  (EV_A_ &linuxaio_epoll_w, linuxaio_epoll_cb, backend_fd, EV_READ);
   ev_set_priority (&linuxaio_epoll_w, EV_MAXPRI);
   ev_io_start (EV_A_ &linuxaio_epoll_w);
   ev_unref (EV_A); /* watcher should not keep loop alive */
-  backend_modify  = linuxaio_modify;
+  backend_modify = linuxaio_modify;
-  backend_poll    = linuxaio_poll;
+  backend_poll   = linuxaio_poll;
   linuxaio_iocbpmax = 0;
   linuxaio_iocbps = 0;
   linuxaio_submits = 0;
 void
 linuxaio_destroy (EV_P)
 {
   epoll_destroy (EV_A);
   linuxaio_free_iocbp (EV_A);
-  evsys_io_destroy (linuxaio_ctx);
+  evsys_io_destroy (linuxaio_ctx); /* fails in child, aio context is destroyed */
 }
-inline_size
+ecb_cold
-void
+static void
 linuxaio_fork (EV_P)
 {
   /* this frees all iocbs, which is very heavy-handed */
   linuxaio_destroy (EV_A);
   linuxaio_submitcnt = 0; /* all pointers were invalidated */
   linuxaio_iteration = 0; /* we start over in the child */
   while (linuxaio_io_setup (EV_A) < 0)
     ev_syserr ("(libev) linuxaio io_setup");
+  /* forking epoll should also effectively unregister all fds from the backend */
   epoll_fork (EV_A);
+  /* epoll_fork already did this. hopefully */
+  /*fd_rearm_all (EV_A);*/
   ev_io_stop  (EV_A_ &linuxaio_epoll_w);
   ev_io_set   (EV_A_ &linuxaio_epoll_w, backend_fd, EV_READ);
   ev_io_start (EV_A_ &linuxaio_epoll_w);
-  /* epoll_fork already did this. hopefully */
-  /*fd_rearm_all (EV_A);*/
 }

Diff Legend

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

Comparing libev/ev_linuxaio.c (file contents): Revision 1.25 by root, Tue Jun 25 04:52:30 2019 UTC vs. Revision 1.45 by root, Thu Jul 4 23:59:36 2019 UTC

Diff Legend

Comparing libev/ev_linuxaio.c (file contents):
Revision 1.25 by root, Tue Jun 25 04:52:30 2019 UTC vs.
Revision 1.45 by root, Thu Jul 4 23:59:36 2019 UTC