[ViewVC] Diff of: cvs/libev/ev

Comparing libev/ev_linuxaio.c (file contents):
Revision 1.37 by root, Wed Jun 26 07:20:09 2019 UTC vs.
Revision 1.44 by root, Tue Jul 2 06:07:54 2019 UTC

   unsigned header_length;  /* size of aio_ring */
   struct io_event io_events[0];
 };
-/*
- * define some syscall wrappers for common architectures
- * this is mostly for nice looks during debugging, not performance.
- * our syscalls return < 0, not == -1, on error. which is good
- * enough for linux aio.
- * TODO: arm is also common nowadays, maybe even mips and x86
- * TODO: after implementing this, it suddenly looks like overkill, but its hard to remove...
- */
-#if __GNUC__ && __linux && ECB_AMD64 && !defined __OPTIMIZE_SIZE__
-  /* the costly errno access probably kills this for size optimisation */
-  #define ev_syscall(nr,narg,arg1,arg2,arg3,arg4,arg5)                 \
-    ({                                                                 \
-        long res;                                                      \
-        register unsigned long r5 __asm__ ("r8" );                     \
-        register unsigned long r4 __asm__ ("r10");                     \
-        register unsigned long r3 __asm__ ("rdx");                     \
-        register unsigned long r2 __asm__ ("rsi");                     \
-        register unsigned long r1 __asm__ ("rdi");                     \
-        if (narg >= 5) r5 = (unsigned long)(arg5);                     \
-        if (narg >= 4) r4 = (unsigned long)(arg4);                     \
-        if (narg >= 3) r3 = (unsigned long)(arg3);                     \
-        if (narg >= 2) r2 = (unsigned long)(arg2);                     \
-        if (narg >= 1) r1 = (unsigned long)(arg1);                     \
-        __asm__ __volatile__ (                                         \
-          "syscall\n\t"                                                \
-          : "=a" (res)                                                 \
-          : "0" (nr), "r" (r1), "r" (r2), "r" (r3), "r" (r4), "r" (r5) \
-          : "cc", "r11", "cx", "memory");                              \
-        errno = -res;                                                  \
-        res;                                                           \
-    })
-#endif
-#ifdef ev_syscall
-  #define ev_syscall0(nr)                          ev_syscall (nr, 0,    0,    0,    0,    0,    0
-  #define ev_syscall1(nr,arg1)                     ev_syscall (nr, 1, arg1,    0,    0,    0,    0)
-  #define ev_syscall2(nr,arg1,arg2)                ev_syscall (nr, 2, arg1, arg2,    0,    0,    0)
-  #define ev_syscall3(nr,arg1,arg2,arg3)           ev_syscall (nr, 3, arg1, arg2, arg3,    0,    0)
-  #define ev_syscall4(nr,arg1,arg2,arg3,arg4)      ev_syscall (nr, 3, arg1, arg2, arg3, arg4,    0)
-  #define ev_syscall5(nr,arg1,arg2,arg3,arg4,arg5) ev_syscall (nr, 5, arg1, arg2, arg3, arg4, arg5)
-#else
-  #define ev_syscall0(nr)                          syscall (nr)
-  #define ev_syscall1(nr,arg1)                     syscall (nr, arg1)
-  #define ev_syscall2(nr,arg1,arg2)                syscall (nr, arg1, arg2)
-  #define ev_syscall3(nr,arg1,arg2,arg3)           syscall (nr, arg1, arg2, arg3)
-  #define ev_syscall4(nr,arg1,arg2,arg3,arg4)      syscall (nr, arg1, arg2, arg3, arg4)
-  #define ev_syscall5(nr,arg1,arg2,arg3,arg4,arg5) syscall (nr, arg1, arg2, arg3, arg4, arg5)
-#endif
 inline_size
 int
 evsys_io_setup (unsigned nr_events, aio_context_t *ctx_idp)
 {
   return ev_syscall2 (SYS_io_setup, nr_events, ctx_idp);
 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 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 (iocb->io.aio_buf)
+  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" */
-      evsys_io_cancel (linuxaio_ctx, &iocb->io, (struct io_event *)0);
+          if (ecb_expect_false (evsys_io_cancel (linuxaio_ctx, &iocb->io, (struct io_event *)0) == 0))
-      /* on relevant kernels, io_cancel fails with EINPROGRES if everything is fine */
+            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));
+          assert (("libev: linuxaio unexpected io_cancel failed", errno != EINPROGRESS && errno != EINTR));
-    }
+       }
+    }
+  iocb->io.aio_buf =
+      (nev & EV_READ ? POLLIN : 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;
 /* 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 */
     linuxaio_parse_events (EV_A_ ring->io_events + head, tail - head);
   else /* wrapped around */
 int
 linuxaio_ringbuf_valid (EV_P)
 {
   struct aio_ring *ring = (struct aio_ring *)linuxaio_ctx;
-  return expect_true (ring->magic == AIO_RING_MAGIC)
+  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 */
   struct timespec ts;
   struct io_event ioev[8]; /* 256 octet stack space */
   int want = 1; /* how many events to request */
   int ringbuf_valid = linuxaio_ringbuf_valid (EV_A);
-  if (expect_true (ringbuf_valid))
+  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))
         return;
     {
       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)
       else if (res)
         {
           /* at least one event available, handle them */
           linuxaio_parse_events (EV_A_ ioev, res);
-          if (expect_true (ringbuf_valid))
+          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);
               /* at this point, we should have handled all outstanding events */
   /* 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.
             }
             ++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;
             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;
   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 */
   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.37 by root, Wed Jun 26 07:20:09 2019 UTC vs. Revision 1.44 by root, Tue Jul 2 06:07:54 2019 UTC

Diff Legend

Comparing libev/ev_linuxaio.c (file contents):
Revision 1.37 by root, Wed Jun 26 07:20:09 2019 UTC vs.
Revision 1.44 by root, Tue Jul 2 06:07:54 2019 UTC