Teach unix_latch.c to use poll() where available.

poll() is preferred over select() on platforms where both are available,
because it tends to be a bit faster and it doesn't have an arbitrary limit
on the range of FD numbers that can be accessed.  The FD range limit does
not appear to be a risk factor for any 9.1 usages, so this doesn't need to
be back-patched, but we need to have it in place if we keep on expanding
the uses of WaitLatch.

diff --git a/src/backend/port/unix_latch.c b/src/backend/port/unix_latch.c
index a7482facebc0c8fe0d5047cbd1f889aa889c293d..02894976c06aff1281bb6ebaea7febd5c0ee5296 100644 (file)
--- a/src/backend/port/unix_latch.c
+++ b/src/backend/port/unix_latch.c
@@ -14,6 +14,9 @@
  * however reliably interrupts the sleep, and causes select() to return
  * immediately even if the signal arrives before select() begins.
  *
+ * (Actually, we prefer poll() over select() where available, but the
+ * same comments apply to it.)
+ *
  * When SetLatch is called from the same process that owns the latch,
  * SetLatch writes the byte directly to the pipe. If it's owned by another
  * process, SIGUSR1 is sent and the signal handler in the waiting process
@@ -34,6 +37,12 @@
 #include <unistd.h>
 #include <sys/time.h>
 #include <sys/types.h>
+#ifdef HAVE_POLL_H
+#include <poll.h>
+#endif
+#ifdef HAVE_SYS_POLL_H
+#include <sys/poll.h>
+#endif
 #ifdef HAVE_SYS_SELECT_H
 #include <sys/select.h>
 #endif
@@ -175,12 +184,18 @@ int
 WaitLatchOrSocket(volatile Latch *latch, int wakeEvents, pgsocket sock,
                                  long timeout)
 {
+       int                     result = 0;
+       int                     rc;
+#ifdef HAVE_POLL
+       struct pollfd pfds[3];
+       int                     nfds;
+#else
        struct timeval tv,
                           *tvp = NULL;
        fd_set          input_mask;
        fd_set          output_mask;
-       int                     rc;
-       int                     result = 0;
+       int                     hifd;
+#endif
 
        /* Ignore WL_SOCKET_* events if no valid socket is given */
        if (sock == PGINVALID_SOCKET)
@@ -195,21 +210,29 @@ WaitLatchOrSocket(volatile Latch *latch, int wakeEvents, pgsocket sock,
        if (wakeEvents & WL_TIMEOUT)
        {
                Assert(timeout >= 0);
+#ifndef HAVE_POLL
                tv.tv_sec = timeout / 1000L;
                tv.tv_usec = (timeout % 1000L) * 1000L;
                tvp = &tv;
+#endif
+       }
+       else
+       {
+#ifdef HAVE_POLL
+               /* make sure poll() agrees there is no timeout */
+               timeout = -1;
+#endif
        }
 
        waiting = true;
        do
        {
-               int                     hifd;
-
                /*
                 * Clear the pipe, then check if the latch is set already. If someone
-                * sets the latch between this and the select() below, the setter will
-                * write a byte to the pipe (or signal us and the signal handler will
-                * do that), and the select() will return immediately.
+                * sets the latch between this and the poll()/select() below, the
+                * setter will write a byte to the pipe (or signal us and the signal
+                * handler will do that), and the poll()/select() will return
+                * immediately.
                 *
                 * Note: we assume that the kernel calls involved in drainSelfPipe()
                 * and SetLatch() will provide adequate synchronization on machines
@@ -228,7 +251,73 @@ WaitLatchOrSocket(volatile Latch *latch, int wakeEvents, pgsocket sock,
                        break;
                }
 
-               /* Must wait ... set up the event masks for select() */
+               /* Must wait ... we use poll(2) if available, otherwise select(2) */
+#ifdef HAVE_POLL
+               nfds = 0;
+               if (wakeEvents & (WL_SOCKET_READABLE | WL_SOCKET_WRITEABLE))
+               {
+                       /* socket, if used, is always in pfds[0] */
+                       pfds[0].fd = sock;
+                       pfds[0].events = 0;
+                       if (wakeEvents & WL_SOCKET_READABLE)
+                               pfds[0].events |= POLLIN;
+                       if (wakeEvents & WL_SOCKET_WRITEABLE)
+                               pfds[0].events |= POLLOUT;
+                       pfds[0].revents = 0;
+                       nfds++;
+               }
+
+               pfds[nfds].fd = selfpipe_readfd;
+               pfds[nfds].events = POLLIN;
+               pfds[nfds].revents = 0;
+               nfds++;
+
+               if (wakeEvents & WL_POSTMASTER_DEATH)
+               {
+                       /* postmaster fd, if used, is always in pfds[nfds - 1] */
+                       pfds[nfds].fd = postmaster_alive_fds[POSTMASTER_FD_WATCH];
+                       pfds[nfds].events = POLLIN;
+                       pfds[nfds].revents = 0;
+                       nfds++;
+               }
+
+               /* Sleep */
+               rc = poll(pfds, nfds, (int) timeout);
+
+               /* Check return code */
+               if (rc < 0)
+               {
+                       if (errno == EINTR)
+                               continue;
+                       waiting = false;
+                       ereport(ERROR,
+                                       (errcode_for_socket_access(),
+                                        errmsg("poll() failed: %m")));
+               }
+               if (rc == 0 && (wakeEvents & WL_TIMEOUT))
+               {
+                       /* timeout exceeded */
+                       result |= WL_TIMEOUT;
+               }
+               if ((wakeEvents & WL_SOCKET_READABLE) &&
+                       (pfds[0].revents & POLLIN))
+               {
+                       /* data available in socket */
+                       result |= WL_SOCKET_READABLE;
+               }
+               if ((wakeEvents & WL_SOCKET_WRITEABLE) &&
+                       (pfds[0].revents & POLLOUT))
+               {
+                       result |= WL_SOCKET_WRITEABLE;
+               }
+               if ((wakeEvents & WL_POSTMASTER_DEATH) &&
+                       (pfds[nfds - 1].revents & POLLIN))
+               {
+                       result |= WL_POSTMASTER_DEATH;
+               }
+
+#else /* !HAVE_POLL */
+
                FD_ZERO(&input_mask);
                FD_ZERO(&output_mask);
 
@@ -288,6 +377,7 @@ WaitLatchOrSocket(volatile Latch *latch, int wakeEvents, pgsocket sock,
                {
                        result |= WL_POSTMASTER_DEATH;
                }
+#endif /* HAVE_POLL */
        } while (result == 0);
        waiting = false;