[ViewVC] Diff of: cvs/libev/ev

Comparing libev/ev_linuxaio.c (file contents):
Revision 1.43 by root, Mon Jul 1 21:47:42 2019 UTC vs.
Revision 1.51 by root, Sat Aug 17 05:30:16 2019 UTC

        * this is not well documented, so we better do it.
        */
       memset (iocb, 0, sizeof (*iocb));
       iocb->io.aio_lio_opcode = IOCB_CMD_POLL;
-      iocb->io.aio_data       = offset;
       iocb->io.aio_fildes     = offset;
       base [offset++] = iocb;
     }
 }
 static void
 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];
+  ANFD *anfd = &anfds [fd];
   if (ecb_expect_false (iocb->io.aio_reqprio < 0))
     {
       /* we handed this fd over to epoll, so undo this first */
       /* 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;
+      anfd->emask = 0;
       iocb->io.aio_reqprio = 0;
     }
-  if (ecb_expect_false (iocb->io.aio_buf))
+  else if (ecb_expect_false (iocb->io.aio_buf))
     {
       /* iocb active, so cancel it first before resubmit */
+      /* this assumes we only ever get one call per fd per loop iteration */
       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. */
+          if (errno != EINTR)
+            {
-          assert (("libev: linuxaio unexpected io_cancel failed", errno != EINPROGRESS && errno != EINTR));
+              assert (("libev: linuxaio unexpected io_cancel failed", errno != EINTR && errno != EINPROGRESS));
+              break;
+            }
        }
+      /* increment generation counter to avoid handling old events */
+      ++anfd->egen;
     }
   iocb->io.aio_buf =
       (nev & EV_READ ? POLLIN : 0)
       | (nev & EV_WRITE ? POLLOUT : 0);
   if (nev)
     {
+      iocb->io.aio_data = (uint32_t)fd | ((__u64)(uint32_t)anfd->egen << 32);
       /* 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;
 static void
 linuxaio_parse_events (EV_P_ struct io_event *ev, int nr)
 {
   while (nr)
     {
-      int fd  = ev->data;
+      int fd       = ev->data & 0xffffffff;
+      uint32_t gen = ev->data >> 32;
-      int res = ev->res;
+      int res      = ev->res;
       assert (("libev: iocb fd must be in-bounds", fd >= 0 && fd < anfdmax));
+      /* only accept events if generation counter matches */
+      if (ecb_expect_true (gen == (uint32_t)anfds [fd].egen))
+        {
-      /* feed events, we do not expect or handle POLLNVAL */
+          /* feed events, we do not expect or handle POLLNVAL */
-      fd_event (
+          fd_event (
-        EV_A_
+            EV_A_
-        fd,
+            fd,
-        (res & (POLLOUT | POLLERR | POLLHUP) ? EV_WRITE : 0)
+            (res & (POLLOUT | POLLERR | POLLHUP) ? EV_WRITE : 0)
-        | (res & (POLLIN | POLLERR | POLLHUP) ? EV_READ : 0)
+            | (res & (POLLIN | POLLERR | POLLHUP) ? EV_READ : 0)
-      );
+          );
-      /* linux aio is oneshot: rearm fd. TODO: this does more work than strictly needed */
+          /* linux aio is oneshot: rearm fd. TODO: this does more work than strictly needed */
-      linuxaio_fd_rearm (EV_A_ fd);
+          linuxaio_fd_rearm (EV_A_ fd);
+        }
       --nr;
       ++ev;
     }
 }
 /* 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;
-  /* 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);
     {
       int res;
       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);
       EV_ACQUIRE_CB;
       if (res < 0)
             break;
         }
       else
         break; /* no events from the kernel, we are done */
-      timeout = 0; /* only wait in the first iteration */
+      timeout = EV_TS_CONST (0.); /* only wait in the first iteration */
     }
 }
 inline_size
 int
             }
             ++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;
+            timeout = EV_TS_CONST (0.);
             /* it's easiest to handle this mess in another iteration */
             return;
           }
         else if (errno == EBADF)
           {
             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;
   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;
   epoll_destroy (EV_A);
   linuxaio_free_iocbp (EV_A);
   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_free_iocbp (EV_A); /* this frees all iocbs, which is very heavy-handed */
+  evsys_io_destroy (linuxaio_ctx); /* fails in child, aio context is destroyed */
   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.43 by root, Mon Jul 1 21:47:42 2019 UTC vs. Revision 1.51 by root, Sat Aug 17 05:30:16 2019 UTC

Diff Legend

Comparing libev/ev_linuxaio.c (file contents):
Revision 1.43 by root, Mon Jul 1 21:47:42 2019 UTC vs.
Revision 1.51 by root, Sat Aug 17 05:30:16 2019 UTC