grpc 1.7.3 → 1.8.0

data/src/core/lib/iomgr/ev_epollsig_linux.h

@@ -22,12 +22,20 @@
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/port.h"
 
-const grpc_event_engine_vtable *grpc_init_epollsig_linux(bool explicit_request);
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+const grpc_event_engine_vtable* grpc_init_epollsig_linux(bool explicit_request);
 
 #ifdef GRPC_LINUX_EPOLL
-void *grpc_fd_get_polling_island(grpc_fd *fd);
-void *grpc_pollset_get_polling_island(grpc_pollset *ps);
-bool grpc_are_polling_islands_equal(void *p, void *q);
+void* grpc_fd_get_polling_island(grpc_fd* fd);
+void* grpc_pollset_get_polling_island(grpc_pollset* ps);
+bool grpc_are_polling_islands_equal(void* p, void* q);
 #endif /* defined(GRPC_LINUX_EPOLL) */
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_LIB_IOMGR_EV_EPOLLSIG_LINUX_H */

data/src/core/lib/iomgr/{ev_poll_posix.c → ev_poll_posix.cc}

@@ -24,6 +24,7 @@
 
 #include <assert.h>
 #include <errno.h>
+#include <limits.h>
 #include <poll.h>
 #include <string.h>
 #include <sys/socket.h>
@@ -37,26 +38,24 @@
 #include <grpc/support/useful.h>
 
 #include "src/core/lib/debug/stats.h"
+#include "src/core/lib/iomgr/block_annotate.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
-#include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/iomgr/wakeup_fd_cv.h"
 #include "src/core/lib/iomgr/wakeup_fd_posix.h"
 #include "src/core/lib/profiling/timers.h"
-#include "src/core/lib/support/block_annotate.h"
 #include "src/core/lib/support/murmur_hash.h"
 
-#define GRPC_POLLSET_KICK_BROADCAST ((grpc_pollset_worker *)1)
+#define GRPC_POLLSET_KICK_BROADCAST ((grpc_pollset_worker*)1)
 
 /*******************************************************************************
  * FD declarations
  */
-
 typedef struct grpc_fd_watcher {
-  struct grpc_fd_watcher *next;
-  struct grpc_fd_watcher *prev;
-  grpc_pollset *pollset;
-  grpc_pollset_worker *worker;
-  grpc_fd *fd;
+  struct grpc_fd_watcher* next;
+  struct grpc_fd_watcher* prev;
+  grpc_pollset* pollset;
+  grpc_pollset_worker* worker;
+  grpc_fd* fd;
 } grpc_fd_watcher;
 
 struct grpc_fd {
@@ -72,7 +71,7 @@ struct grpc_fd {
   int shutdown;
   int closed;
   int released;
-  grpc_error *shutdown_error;
+  grpc_error* shutdown_error;
 
   /* The watcher list.
 
@@ -97,18 +96,18 @@ struct grpc_fd {
      the inactive pollers may be kicked out of their poll loops to take
      that responsibility. */
   grpc_fd_watcher inactive_watcher_root;
-  grpc_fd_watcher *read_watcher;
-  grpc_fd_watcher *write_watcher;
+  grpc_fd_watcher* read_watcher;
+  grpc_fd_watcher* write_watcher;
 
-  grpc_closure *read_closure;
-  grpc_closure *write_closure;
+  grpc_closure* read_closure;
+  grpc_closure* write_closure;
 
-  grpc_closure *on_done_closure;
+  grpc_closure* on_done_closure;
 
   grpc_iomgr_object iomgr_object;
 
   /* The pollset that last noticed and notified that the fd is readable */
-  grpc_pollset *read_notifier_pollset;
+  grpc_pollset* read_notifier_pollset;
 };
 
 /* Begin polling on an fd.
@@ -122,35 +121,35 @@ struct grpc_fd {
    Polling strategies that do not need to alter their behavior depending on the
    fd's current interest (such as epoll) do not need to call this function.
    MUST NOT be called with a pollset lock taken */
-static uint32_t fd_begin_poll(grpc_fd *fd, grpc_pollset *pollset,
-                              grpc_pollset_worker *worker, uint32_t read_mask,
-                              uint32_t write_mask, grpc_fd_watcher *rec);
+static uint32_t fd_begin_poll(grpc_fd* fd, grpc_pollset* pollset,
+                              grpc_pollset_worker* worker, uint32_t read_mask,
+                              uint32_t write_mask, grpc_fd_watcher* rec);
 /* Complete polling previously started with fd_begin_poll
    MUST NOT be called with a pollset lock taken
    if got_read or got_write are 1, also does the become_{readable,writable} as
    appropriate. */
-static void fd_end_poll(grpc_exec_ctx *exec_ctx, grpc_fd_watcher *rec,
+static void fd_end_poll(grpc_exec_ctx* exec_ctx, grpc_fd_watcher* rec,
                         int got_read, int got_write,
-                        grpc_pollset *read_notifier_pollset);
+                        grpc_pollset* read_notifier_pollset);
 
 /* Return 1 if this fd is orphaned, 0 otherwise */
-static bool fd_is_orphaned(grpc_fd *fd);
+static bool fd_is_orphaned(grpc_fd* fd);
 
 #ifndef NDEBUG
-static void fd_ref(grpc_fd *fd, const char *reason, const char *file, int line);
-static void fd_unref(grpc_fd *fd, const char *reason, const char *file,
+static void fd_ref(grpc_fd* fd, const char* reason, const char* file, int line);
+static void fd_unref(grpc_fd* fd, const char* reason, const char* file,
                      int line);
 #define GRPC_FD_REF(fd, reason) fd_ref(fd, reason, __FILE__, __LINE__)
 #define GRPC_FD_UNREF(fd, reason) fd_unref(fd, reason, __FILE__, __LINE__)
 #else
-static void fd_ref(grpc_fd *fd);
-static void fd_unref(grpc_fd *fd);
+static void fd_ref(grpc_fd* fd);
+static void fd_unref(grpc_fd* fd);
 #define GRPC_FD_REF(fd, reason) fd_ref(fd)
 #define GRPC_FD_UNREF(fd, reason) fd_unref(fd)
 #endif
 
-#define CLOSURE_NOT_READY ((grpc_closure *)0)
-#define CLOSURE_READY ((grpc_closure *)1)
+#define CLOSURE_NOT_READY ((grpc_closure*)0)
+#define CLOSURE_READY ((grpc_closure*)1)
 
 /*******************************************************************************
  * pollset declarations
@@ -158,15 +157,15 @@ static void fd_unref(grpc_fd *fd);
 
 typedef struct grpc_cached_wakeup_fd {
   grpc_wakeup_fd fd;
-  struct grpc_cached_wakeup_fd *next;
+  struct grpc_cached_wakeup_fd* next;
 } grpc_cached_wakeup_fd;
 
 struct grpc_pollset_worker {
-  grpc_cached_wakeup_fd *wakeup_fd;
+  grpc_cached_wakeup_fd* wakeup_fd;
   int reevaluate_polling_on_wakeup;
   int kicked_specifically;
-  struct grpc_pollset_worker *next;
-  struct grpc_pollset_worker *prev;
+  struct grpc_pollset_worker* next;
+  struct grpc_pollset_worker* prev;
 };
 
 struct grpc_pollset {
@@ -175,23 +174,23 @@ struct grpc_pollset {
   int shutting_down;
   int called_shutdown;
   int kicked_without_pollers;
-  grpc_closure *shutdown_done;
+  grpc_closure* shutdown_done;
   grpc_closure_list idle_jobs;
   int pollset_set_count;
   /* all polled fds */
   size_t fd_count;
   size_t fd_capacity;
-  grpc_fd **fds;
+  grpc_fd** fds;
   /* Local cache of eventfds for workers */
-  grpc_cached_wakeup_fd *local_wakeup_cache;
+  grpc_cached_wakeup_fd* local_wakeup_cache;
 };
 
 /* Add an fd to a pollset */
-static void pollset_add_fd(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
-                           struct grpc_fd *fd);
+static void pollset_add_fd(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
+                           struct grpc_fd* fd);
 
-static void pollset_set_add_fd(grpc_exec_ctx *exec_ctx,
-                               grpc_pollset_set *pollset_set, grpc_fd *fd);
+static void pollset_set_add_fd(grpc_exec_ctx* exec_ctx,
+                               grpc_pollset_set* pollset_set, grpc_fd* fd);
 
 /* Convert a timespec to milliseconds:
    - very small or negative poll times are clamped to zero to do a
@@ -200,8 +199,8 @@ static void pollset_set_add_fd(grpc_exec_ctx *exec_ctx,
    - longer than a millisecond polls are rounded up to the next nearest
      millisecond to avoid spinning
    - infinite timeouts are converted to -1 */
-static int poll_deadline_to_millis_timeout(gpr_timespec deadline,
-                                           gpr_timespec now);
+static int poll_deadline_to_millis_timeout(grpc_exec_ctx* exec_ctx,
+                                           grpc_millis deadline);
 
 /* Allow kick to wakeup the currently polling worker */
 #define GRPC_POLLSET_CAN_KICK_SELF 1
@@ -209,13 +208,13 @@ static int poll_deadline_to_millis_timeout(gpr_timespec deadline,
 #define GRPC_POLLSET_REEVALUATE_POLLING_ON_WAKEUP 2
 /* As per pollset_kick, with an extended set of flags (defined above)
    -- mostly for fd_posix's use. */
-static grpc_error *pollset_kick_ext(grpc_exec_ctx *exec_ctx, grpc_pollset *p,
-                                    grpc_pollset_worker *specific_worker,
+static grpc_error* pollset_kick_ext(grpc_exec_ctx* exec_ctx, grpc_pollset* p,
+                                    grpc_pollset_worker* specific_worker,
                                     uint32_t flags) GRPC_MUST_USE_RESULT;
 
 /* Return 1 if the pollset has active threads in pollset_work (pollset must
  * be locked) */
-static bool pollset_has_workers(grpc_pollset *pollset);
+static bool pollset_has_workers(grpc_pollset* pollset);
 
 /*******************************************************************************
  * pollset_set definitions
@@ -226,15 +225,15 @@ struct grpc_pollset_set {
 
   size_t pollset_count;
   size_t pollset_capacity;
-  grpc_pollset **pollsets;
+  grpc_pollset** pollsets;
 
   size_t pollset_set_count;
   size_t pollset_set_capacity;
-  struct grpc_pollset_set **pollset_sets;
+  struct grpc_pollset_set** pollset_sets;
 
   size_t fd_count;
   size_t fd_capacity;
-  grpc_fd **fds;
+  grpc_fd** fds;
 };
 
 /*******************************************************************************
@@ -247,9 +246,9 @@ struct grpc_pollset_set {
 
 typedef struct poll_result {
   gpr_refcount refcount;
-  cv_node *watchers;
+  cv_node* watchers;
   int watchcount;
-  struct pollfd *fds;
+  struct pollfd* fds;
   nfds_t nfds;
   int retval;
   int err;
@@ -259,11 +258,11 @@ typedef struct poll_result {
 typedef struct poll_args {
   gpr_cv trigger;
   int trigger_set;
-  struct pollfd *fds;
+  struct pollfd* fds;
   nfds_t nfds;
-  poll_result *result;
-  struct poll_args *next;
-  struct poll_args *prev;
+  poll_result* result;
+  struct poll_args* next;
+  struct poll_args* prev;
 } poll_args;
 
 // This is a 2-tiered cache, we mantain a hash table
@@ -271,8 +270,8 @@ typedef struct poll_args {
 // of that call.  We also maintain a freelist of inactive
 // poll threads.
 typedef struct poll_hash_table {
-  poll_args *free_pollers;
-  poll_args **active_pollers;
+  poll_args* free_pollers;
+  poll_args** active_pollers;
   unsigned int size;
   unsigned int count;
 } poll_hash_table;
@@ -287,9 +286,9 @@ cv_fd_table g_cvfds;
 #ifndef NDEBUG
 #define REF_BY(fd, n, reason) ref_by(fd, n, reason, __FILE__, __LINE__)
 #define UNREF_BY(fd, n, reason) unref_by(fd, n, reason, __FILE__, __LINE__)
-static void ref_by(grpc_fd *fd, int n, const char *reason, const char *file,
+static void ref_by(grpc_fd* fd, int n, const char* reason, const char* file,
                    int line) {
-  if (GRPC_TRACER_ON(grpc_trace_fd_refcount)) {
+  if (grpc_trace_fd_refcount.enabled()) {
     gpr_log(GPR_DEBUG,
             "FD %d %p   ref %d %" PRIdPTR " -> %" PRIdPTR " [%s; %s:%d]",
             fd->fd, fd, n, gpr_atm_no_barrier_load(&fd->refst),
@@ -298,22 +297,22 @@ static void ref_by(grpc_fd *fd, int n, const char *reason, const char *file,
 #else
 #define REF_BY(fd, n, reason) ref_by(fd, n)
 #define UNREF_BY(fd, n, reason) unref_by(fd, n)
-static void ref_by(grpc_fd *fd, int n) {
+static void ref_by(grpc_fd* fd, int n) {
 #endif
   GPR_ASSERT(gpr_atm_no_barrier_fetch_add(&fd->refst, n) > 0);
 }
 
 #ifndef NDEBUG
-static void unref_by(grpc_fd *fd, int n, const char *reason, const char *file,
+static void unref_by(grpc_fd* fd, int n, const char* reason, const char* file,
                      int line) {
-  if (GRPC_TRACER_ON(grpc_trace_fd_refcount)) {
+  if (grpc_trace_fd_refcount.enabled()) {
     gpr_log(GPR_DEBUG,
             "FD %d %p unref %d %" PRIdPTR " -> %" PRIdPTR " [%s; %s:%d]",
             fd->fd, fd, n, gpr_atm_no_barrier_load(&fd->refst),
             gpr_atm_no_barrier_load(&fd->refst) - n, reason, file, line);
   }
 #else
-static void unref_by(grpc_fd *fd, int n) {
+static void unref_by(grpc_fd* fd, int n) {
 #endif
   gpr_atm old = gpr_atm_full_fetch_add(&fd->refst, -n);
   if (old == n) {
@@ -326,8 +325,8 @@ static void unref_by(grpc_fd *fd, int n) {
   }
 }
 
-static grpc_fd *fd_create(int fd, const char *name) {
-  grpc_fd *r = (grpc_fd *)gpr_malloc(sizeof(*r));
+static grpc_fd* fd_create(int fd, const char* name) {
+  grpc_fd* r = (grpc_fd*)gpr_malloc(sizeof(*r));
   gpr_mu_init(&r->mu);
   gpr_atm_rel_store(&r->refst, 1);
   r->shutdown = 0;
@@ -336,27 +335,27 @@ static grpc_fd *fd_create(int fd, const char *name) {
   r->fd = fd;
   r->inactive_watcher_root.next = r->inactive_watcher_root.prev =
       &r->inactive_watcher_root;
-  r->read_watcher = r->write_watcher = NULL;
-  r->on_done_closure = NULL;
+  r->read_watcher = r->write_watcher = nullptr;
+  r->on_done_closure = nullptr;
   r->closed = 0;
   r->released = 0;
-  r->read_notifier_pollset = NULL;
+  r->read_notifier_pollset = nullptr;
 
-  char *name2;
+  char* name2;
   gpr_asprintf(&name2, "%s fd=%d", name, fd);
   grpc_iomgr_register_object(&r->iomgr_object, name2);
   gpr_free(name2);
   return r;
 }
 
-static bool fd_is_orphaned(grpc_fd *fd) {
+static bool fd_is_orphaned(grpc_fd* fd) {
   return (gpr_atm_acq_load(&fd->refst) & 1) == 0;
 }
 
 /* Return the read-notifier pollset */
-static grpc_pollset *fd_get_read_notifier_pollset(grpc_exec_ctx *exec_ctx,
-                                                  grpc_fd *fd) {
-  grpc_pollset *notifier = NULL;
+static grpc_pollset* fd_get_read_notifier_pollset(grpc_exec_ctx* exec_ctx,
+                                                  grpc_fd* fd) {
+  grpc_pollset* notifier = nullptr;
 
   gpr_mu_lock(&fd->mu);
   notifier = fd->read_notifier_pollset;
@@ -365,19 +364,19 @@ static grpc_pollset *fd_get_read_notifier_pollset(grpc_exec_ctx *exec_ctx,
   return notifier;
 }
 
-static grpc_error *pollset_kick_locked(grpc_exec_ctx *exec_ctx,
-                                       grpc_fd_watcher *watcher) {
+static grpc_error* pollset_kick_locked(grpc_exec_ctx* exec_ctx,
+                                       grpc_fd_watcher* watcher) {
   gpr_mu_lock(&watcher->pollset->mu);
   GPR_ASSERT(watcher->worker);
-  grpc_error *err =
+  grpc_error* err =
       pollset_kick_ext(exec_ctx, watcher->pollset, watcher->worker,
                        GRPC_POLLSET_REEVALUATE_POLLING_ON_WAKEUP);
   gpr_mu_unlock(&watcher->pollset->mu);
   return err;
 }
 
-static void maybe_wake_one_watcher_locked(grpc_exec_ctx *exec_ctx,
-                                          grpc_fd *fd) {
+static void maybe_wake_one_watcher_locked(grpc_exec_ctx* exec_ctx,
+                                          grpc_fd* fd) {
   if (fd->inactive_watcher_root.next != &fd->inactive_watcher_root) {
     pollset_kick_locked(exec_ctx, fd->inactive_watcher_root.next);
   } else if (fd->read_watcher) {
@@ -387,8 +386,8 @@ static void maybe_wake_one_watcher_locked(grpc_exec_ctx *exec_ctx,
   }
 }
 
-static void wake_all_watchers_locked(grpc_exec_ctx *exec_ctx, grpc_fd *fd) {
-  grpc_fd_watcher *watcher;
+static void wake_all_watchers_locked(grpc_exec_ctx* exec_ctx, grpc_fd* fd) {
+  grpc_fd_watcher* watcher;
   for (watcher = fd->inactive_watcher_root.next;
        watcher != &fd->inactive_watcher_root; watcher = watcher->next) {
     pollset_kick_locked(exec_ctx, watcher);
@@ -401,12 +400,12 @@ static void wake_all_watchers_locked(grpc_exec_ctx *exec_ctx, grpc_fd *fd) {
   }
 }
 
-static int has_watchers(grpc_fd *fd) {
-  return fd->read_watcher != NULL || fd->write_watcher != NULL ||
+static int has_watchers(grpc_fd* fd) {
+  return fd->read_watcher != nullptr || fd->write_watcher != nullptr ||
          fd->inactive_watcher_root.next != &fd->inactive_watcher_root;
 }
 
-static void close_fd_locked(grpc_exec_ctx *exec_ctx, grpc_fd *fd) {
+static void close_fd_locked(grpc_exec_ctx* exec_ctx, grpc_fd* fd) {
   fd->closed = 1;
   if (!fd->released) {
     close(fd->fd);
@@ -414,7 +413,7 @@ static void close_fd_locked(grpc_exec_ctx *exec_ctx, grpc_fd *fd) {
   GRPC_CLOSURE_SCHED(exec_ctx, fd->on_done_closure, GRPC_ERROR_NONE);
 }
 
-static int fd_wrapped_fd(grpc_fd *fd) {
+static int fd_wrapped_fd(grpc_fd* fd) {
   if (fd->released || fd->closed) {
     return -1;
   } else {
@@ -422,12 +421,12 @@ static int fd_wrapped_fd(grpc_fd *fd) {
   }
 }
 
-static void fd_orphan(grpc_exec_ctx *exec_ctx, grpc_fd *fd,
-                      grpc_closure *on_done, int *release_fd,
-                      bool already_closed, const char *reason) {
+static void fd_orphan(grpc_exec_ctx* exec_ctx, grpc_fd* fd,
+                      grpc_closure* on_done, int* release_fd,
+                      bool already_closed, const char* reason) {
   fd->on_done_closure = on_done;
-  fd->released = release_fd != NULL;
-  if (release_fd != NULL) {
+  fd->released = release_fd != nullptr;
+  if (release_fd != nullptr) {
     *release_fd = fd->fd;
     fd->released = true;
   } else if (already_closed) {
@@ -446,22 +445,22 @@ static void fd_orphan(grpc_exec_ctx *exec_ctx, grpc_fd *fd,
 
 /* increment refcount by two to avoid changing the orphan bit */
 #ifndef NDEBUG
-static void fd_ref(grpc_fd *fd, const char *reason, const char *file,
+static void fd_ref(grpc_fd* fd, const char* reason, const char* file,
                    int line) {
   ref_by(fd, 2, reason, file, line);
 }
 
-static void fd_unref(grpc_fd *fd, const char *reason, const char *file,
+static void fd_unref(grpc_fd* fd, const char* reason, const char* file,
                      int line) {
   unref_by(fd, 2, reason, file, line);
 }
 #else
-static void fd_ref(grpc_fd *fd) { ref_by(fd, 2); }
+static void fd_ref(grpc_fd* fd) { ref_by(fd, 2); }
 
-static void fd_unref(grpc_fd *fd) { unref_by(fd, 2); }
+static void fd_unref(grpc_fd* fd) { unref_by(fd, 2); }
 #endif
 
-static grpc_error *fd_shutdown_error(grpc_fd *fd) {
+static grpc_error* fd_shutdown_error(grpc_fd* fd) {
   if (!fd->shutdown) {
     return GRPC_ERROR_NONE;
   } else {
@@ -470,8 +469,8 @@ static grpc_error *fd_shutdown_error(grpc_fd *fd) {
   }
 }
 
-static void notify_on_locked(grpc_exec_ctx *exec_ctx, grpc_fd *fd,
-                             grpc_closure **st, grpc_closure *closure) {
+static void notify_on_locked(grpc_exec_ctx* exec_ctx, grpc_fd* fd,
+                             grpc_closure** st, grpc_closure* closure) {
   if (fd->shutdown) {
     GRPC_CLOSURE_SCHED(exec_ctx, closure,
                        GRPC_ERROR_CREATE_FROM_STATIC_STRING("FD shutdown"));
@@ -493,8 +492,8 @@ static void notify_on_locked(grpc_exec_ctx *exec_ctx, grpc_fd *fd,
 }
 
 /* returns 1 if state becomes not ready */
-static int set_ready_locked(grpc_exec_ctx *exec_ctx, grpc_fd *fd,
-                            grpc_closure **st) {
+static int set_ready_locked(grpc_exec_ctx* exec_ctx, grpc_fd* fd,
+                            grpc_closure** st) {
   if (*st == CLOSURE_READY) {
     /* duplicate ready ==> ignore */
     return 0;
@@ -511,11 +510,11 @@ static int set_ready_locked(grpc_exec_ctx *exec_ctx, grpc_fd *fd,
 }
 
 static void set_read_notifier_pollset_locked(
-    grpc_exec_ctx *exec_ctx, grpc_fd *fd, grpc_pollset *read_notifier_pollset) {
+    grpc_exec_ctx* exec_ctx, grpc_fd* fd, grpc_pollset* read_notifier_pollset) {
   fd->read_notifier_pollset = read_notifier_pollset;
 }
 
-static void fd_shutdown(grpc_exec_ctx *exec_ctx, grpc_fd *fd, grpc_error *why) {
+static void fd_shutdown(grpc_exec_ctx* exec_ctx, grpc_fd* fd, grpc_error* why) {
   gpr_mu_lock(&fd->mu);
   /* only shutdown once */
   if (!fd->shutdown) {
@@ -531,32 +530,32 @@ static void fd_shutdown(grpc_exec_ctx *exec_ctx, grpc_fd *fd, grpc_error *why) {
   gpr_mu_unlock(&fd->mu);
 }
 
-static bool fd_is_shutdown(grpc_fd *fd) {
+static bool fd_is_shutdown(grpc_fd* fd) {
   gpr_mu_lock(&fd->mu);
   bool r = fd->shutdown;
   gpr_mu_unlock(&fd->mu);
   return r;
 }
 
-static void fd_notify_on_read(grpc_exec_ctx *exec_ctx, grpc_fd *fd,
-                              grpc_closure *closure) {
+static void fd_notify_on_read(grpc_exec_ctx* exec_ctx, grpc_fd* fd,
+                              grpc_closure* closure) {
   gpr_mu_lock(&fd->mu);
   notify_on_locked(exec_ctx, fd, &fd->read_closure, closure);
   gpr_mu_unlock(&fd->mu);
 }
 
-static void fd_notify_on_write(grpc_exec_ctx *exec_ctx, grpc_fd *fd,
-                               grpc_closure *closure) {
+static void fd_notify_on_write(grpc_exec_ctx* exec_ctx, grpc_fd* fd,
+                               grpc_closure* closure) {
   gpr_mu_lock(&fd->mu);
   notify_on_locked(exec_ctx, fd, &fd->write_closure, closure);
   gpr_mu_unlock(&fd->mu);
 }
 
-static uint32_t fd_begin_poll(grpc_fd *fd, grpc_pollset *pollset,
-                              grpc_pollset_worker *worker, uint32_t read_mask,
-                              uint32_t write_mask, grpc_fd_watcher *watcher) {
+static uint32_t fd_begin_poll(grpc_fd* fd, grpc_pollset* pollset,
+                              grpc_pollset_worker* worker, uint32_t read_mask,
+                              uint32_t write_mask, grpc_fd_watcher* watcher) {
   uint32_t mask = 0;
-  grpc_closure *cur;
+  grpc_closure* cur;
   int requested;
   /* keep track of pollers that have requested our events, in case they change
    */
@@ -566,9 +565,9 @@ static uint32_t fd_begin_poll(grpc_fd *fd, grpc_pollset *pollset,
 
   /* if we are shutdown, then don't add to the watcher set */
   if (fd->shutdown) {
-    watcher->fd = NULL;
-    watcher->pollset = NULL;
-    watcher->worker = NULL;
+    watcher->fd = nullptr;
+    watcher->pollset = nullptr;
+    watcher->worker = nullptr;
     gpr_mu_unlock(&fd->mu);
     GRPC_FD_UNREF(fd, "poll");
     return 0;
@@ -577,7 +576,7 @@ static uint32_t fd_begin_poll(grpc_fd *fd, grpc_pollset *pollset,
   /* if there is nobody polling for read, but we need to, then start doing so */
   cur = fd->read_closure;
   requested = cur != CLOSURE_READY;
-  if (read_mask && fd->read_watcher == NULL && requested) {
+  if (read_mask && fd->read_watcher == nullptr && requested) {
     fd->read_watcher = watcher;
     mask |= read_mask;
   }
@@ -585,12 +584,12 @@ static uint32_t fd_begin_poll(grpc_fd *fd, grpc_pollset *pollset,
    */
   cur = fd->write_closure;
   requested = cur != CLOSURE_READY;
-  if (write_mask && fd->write_watcher == NULL && requested) {
+  if (write_mask && fd->write_watcher == nullptr && requested) {
     fd->write_watcher = watcher;
     mask |= write_mask;
   }
   /* if not polling, remember this watcher in case we need someone to later */
-  if (mask == 0 && worker != NULL) {
+  if (mask == 0 && worker != nullptr) {
     watcher->next = &fd->inactive_watcher_root;
     watcher->prev = watcher->next->prev;
     watcher->next->prev = watcher->prev->next = watcher;
@@ -603,14 +602,14 @@ static uint32_t fd_begin_poll(grpc_fd *fd, grpc_pollset *pollset,
   return mask;
 }
 
-static void fd_end_poll(grpc_exec_ctx *exec_ctx, grpc_fd_watcher *watcher,
+static void fd_end_poll(grpc_exec_ctx* exec_ctx, grpc_fd_watcher* watcher,
                         int got_read, int got_write,
-                        grpc_pollset *read_notifier_pollset) {
+                        grpc_pollset* read_notifier_pollset) {
   int was_polling = 0;
   int kick = 0;
-  grpc_fd *fd = watcher->fd;
+  grpc_fd* fd = watcher->fd;
 
-  if (fd == NULL) {
+  if (fd == nullptr) {
     return;
   }
 
@@ -622,7 +621,7 @@ static void fd_end_poll(grpc_exec_ctx *exec_ctx, grpc_fd_watcher *watcher,
     if (!got_read) {
       kick = 1;
     }
-    fd->read_watcher = NULL;
+    fd->read_watcher = nullptr;
   }
   if (watcher == fd->write_watcher) {
     /* remove write watcher, kick if we still need a write */
@@ -630,9 +629,9 @@ static void fd_end_poll(grpc_exec_ctx *exec_ctx, grpc_fd_watcher *watcher,
     if (!got_write) {
       kick = 1;
     }
-    fd->write_watcher = NULL;
+    fd->write_watcher = nullptr;
   }
-  if (!was_polling && watcher->worker != NULL) {
+  if (!was_polling && watcher->worker != nullptr) {
     /* remove from inactive list */
     watcher->next->prev = watcher->prev;
     watcher->prev->next = watcher->next;
@@ -641,7 +640,7 @@ static void fd_end_poll(grpc_exec_ctx *exec_ctx, grpc_fd_watcher *watcher,
     if (set_ready_locked(exec_ctx, fd, &fd->read_closure)) {
       kick = 1;
     }
-    if (read_notifier_pollset != NULL) {
+    if (read_notifier_pollset != nullptr) {
       set_read_notifier_pollset_locked(exec_ctx, fd, read_notifier_pollset);
     }
   }
@@ -668,46 +667,46 @@ static void fd_end_poll(grpc_exec_ctx *exec_ctx, grpc_fd_watcher *watcher,
 GPR_TLS_DECL(g_current_thread_poller);
 GPR_TLS_DECL(g_current_thread_worker);
 
-static void remove_worker(grpc_pollset *p, grpc_pollset_worker *worker) {
+static void remove_worker(grpc_pollset* p, grpc_pollset_worker* worker) {
   worker->prev->next = worker->next;
   worker->next->prev = worker->prev;
 }
 
-static bool pollset_has_workers(grpc_pollset *p) {
+static bool pollset_has_workers(grpc_pollset* p) {
   return p->root_worker.next != &p->root_worker;
 }
 
-static bool pollset_in_pollset_sets(grpc_pollset *p) {
+static bool pollset_in_pollset_sets(grpc_pollset* p) {
   return p->pollset_set_count;
 }
 
-static bool pollset_has_observers(grpc_pollset *p) {
+static bool pollset_has_observers(grpc_pollset* p) {
   return pollset_has_workers(p) || pollset_in_pollset_sets(p);
 }
 
-static grpc_pollset_worker *pop_front_worker(grpc_pollset *p) {
+static grpc_pollset_worker* pop_front_worker(grpc_pollset* p) {
   if (pollset_has_workers(p)) {
-    grpc_pollset_worker *w = p->root_worker.next;
+    grpc_pollset_worker* w = p->root_worker.next;
     remove_worker(p, w);
     return w;
   } else {
-    return NULL;
+    return nullptr;
   }
 }
 
-static void push_back_worker(grpc_pollset *p, grpc_pollset_worker *worker) {
+static void push_back_worker(grpc_pollset* p, grpc_pollset_worker* worker) {
   worker->next = &p->root_worker;
   worker->prev = worker->next->prev;
   worker->prev->next = worker->next->prev = worker;
 }
 
-static void push_front_worker(grpc_pollset *p, grpc_pollset_worker *worker) {
+static void push_front_worker(grpc_pollset* p, grpc_pollset_worker* worker) {
   worker->prev = &p->root_worker;
   worker->next = worker->prev->next;
   worker->prev->next = worker->next->prev = worker;
 }
 
-static void kick_append_error(grpc_error **composite, grpc_error *error) {
+static void kick_append_error(grpc_error** composite, grpc_error* error) {
   if (error == GRPC_ERROR_NONE) return;
   if (*composite == GRPC_ERROR_NONE) {
     *composite = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Kick Failure");
@@ -715,15 +714,15 @@ static void kick_append_error(grpc_error **composite, grpc_error *error) {
   *composite = grpc_error_add_child(*composite, error);
 }
 
-static grpc_error *pollset_kick_ext(grpc_exec_ctx *exec_ctx, grpc_pollset *p,
-                                    grpc_pollset_worker *specific_worker,
+static grpc_error* pollset_kick_ext(grpc_exec_ctx* exec_ctx, grpc_pollset* p,
+                                    grpc_pollset_worker* specific_worker,
                                     uint32_t flags) {
   GPR_TIMER_BEGIN("pollset_kick_ext", 0);
-  grpc_error *error = GRPC_ERROR_NONE;
+  grpc_error* error = GRPC_ERROR_NONE;
   GRPC_STATS_INC_POLLSET_KICK(exec_ctx);
 
   /* pollset->mu already held */
-  if (specific_worker != NULL) {
+  if (specific_worker != nullptr) {
     if (specific_worker == GRPC_POLLSET_KICK_BROADCAST) {
       GPR_TIMER_BEGIN("pollset_kick_ext.broadcast", 0);
       GPR_ASSERT((flags & GRPC_POLLSET_REEVALUATE_POLLING_ON_WAKEUP) == 0);
@@ -757,7 +756,7 @@ static grpc_error *pollset_kick_ext(grpc_exec_ctx *exec_ctx, grpc_pollset *p,
     GPR_ASSERT((flags & GRPC_POLLSET_REEVALUATE_POLLING_ON_WAKEUP) == 0);
     GPR_TIMER_MARK("kick_anonymous", 0);
     specific_worker = pop_front_worker(p);
-    if (specific_worker != NULL) {
+    if (specific_worker != nullptr) {
       if (gpr_tls_get(&g_current_thread_worker) == (intptr_t)specific_worker) {
         GPR_TIMER_MARK("kick_anonymous_not_self", 0);
         push_back_worker(p, specific_worker);
@@ -766,10 +765,10 @@ static grpc_error *pollset_kick_ext(grpc_exec_ctx *exec_ctx, grpc_pollset *p,
             gpr_tls_get(&g_current_thread_worker) ==
                 (intptr_t)specific_worker) {
           push_back_worker(p, specific_worker);
-          specific_worker = NULL;
+          specific_worker = nullptr;
         }
       }
-      if (specific_worker != NULL) {
+      if (specific_worker != nullptr) {
         GPR_TIMER_MARK("finally_kick", 0);
         push_back_worker(p, specific_worker);
         kick_append_error(
@@ -786,14 +785,14 @@ static grpc_error *pollset_kick_ext(grpc_exec_ctx *exec_ctx, grpc_pollset *p,
   return error;
 }
 
-static grpc_error *pollset_kick(grpc_exec_ctx *exec_ctx, grpc_pollset *p,
-                                grpc_pollset_worker *specific_worker) {
+static grpc_error* pollset_kick(grpc_exec_ctx* exec_ctx, grpc_pollset* p,
+                                grpc_pollset_worker* specific_worker) {
   return pollset_kick_ext(exec_ctx, p, specific_worker, 0);
 }
 
 /* global state management */
 
-static grpc_error *pollset_global_init(void) {
+static grpc_error* pollset_global_init(void) {
   gpr_tls_init(&g_current_thread_poller);
   gpr_tls_init(&g_current_thread_worker);
   return GRPC_ERROR_NONE;
@@ -806,27 +805,27 @@ static void pollset_global_shutdown(void) {
 
 /* main interface */
 
-static void pollset_init(grpc_pollset *pollset, gpr_mu **mu) {
+static void pollset_init(grpc_pollset* pollset, gpr_mu** mu) {
   gpr_mu_init(&pollset->mu);
   *mu = &pollset->mu;
   pollset->root_worker.next = pollset->root_worker.prev = &pollset->root_worker;
   pollset->shutting_down = 0;
   pollset->called_shutdown = 0;
   pollset->kicked_without_pollers = 0;
-  pollset->idle_jobs.head = pollset->idle_jobs.tail = NULL;
-  pollset->local_wakeup_cache = NULL;
+  pollset->idle_jobs.head = pollset->idle_jobs.tail = nullptr;
+  pollset->local_wakeup_cache = nullptr;
   pollset->kicked_without_pollers = 0;
   pollset->fd_count = 0;
   pollset->fd_capacity = 0;
-  pollset->fds = NULL;
+  pollset->fds = nullptr;
   pollset->pollset_set_count = 0;
 }
 
-static void pollset_destroy(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset) {
+static void pollset_destroy(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset) {
   GPR_ASSERT(!pollset_has_workers(pollset));
   GPR_ASSERT(pollset->idle_jobs.head == pollset->idle_jobs.tail);
   while (pollset->local_wakeup_cache) {
-    grpc_cached_wakeup_fd *next = pollset->local_wakeup_cache->next;
+    grpc_cached_wakeup_fd* next = pollset->local_wakeup_cache->next;
     grpc_wakeup_fd_destroy(&pollset->local_wakeup_cache->fd);
     gpr_free(pollset->local_wakeup_cache);
     pollset->local_wakeup_cache = next;
@@ -835,8 +834,8 @@ static void pollset_destroy(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset) {
   gpr_mu_destroy(&pollset->mu);
 }
 
-static void pollset_add_fd(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
-                           grpc_fd *fd) {
+static void pollset_add_fd(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
+                           grpc_fd* fd) {
   gpr_mu_lock(&pollset->mu);
   size_t i;
   /* TODO(ctiller): this is O(num_fds^2); maybe switch to a hash set here */
@@ -846,17 +845,17 @@ static void pollset_add_fd(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
   if (pollset->fd_count == pollset->fd_capacity) {
     pollset->fd_capacity =
         GPR_MAX(pollset->fd_capacity + 8, pollset->fd_count * 3 / 2);
-    pollset->fds = (grpc_fd **)gpr_realloc(
-        pollset->fds, sizeof(grpc_fd *) * pollset->fd_capacity);
+    pollset->fds = (grpc_fd**)gpr_realloc(
+        pollset->fds, sizeof(grpc_fd*) * pollset->fd_capacity);
   }
   pollset->fds[pollset->fd_count++] = fd;
   GRPC_FD_REF(fd, "multipoller");
-  pollset_kick(exec_ctx, pollset, NULL);
+  pollset_kick(exec_ctx, pollset, nullptr);
 exit:
   gpr_mu_unlock(&pollset->mu);
 }
 
-static void finish_shutdown(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset) {
+static void finish_shutdown(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset) {
   GPR_ASSERT(grpc_closure_list_empty(pollset->idle_jobs));
   size_t i;
   for (i = 0; i < pollset->fd_count; i++) {
@@ -866,7 +865,7 @@ static void finish_shutdown(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset) {
   GRPC_CLOSURE_SCHED(exec_ctx, pollset->shutdown_done, GRPC_ERROR_NONE);
 }
 
-static void work_combine_error(grpc_error **composite, grpc_error *error) {
+static void work_combine_error(grpc_error** composite, grpc_error* error) {
   if (error == GRPC_ERROR_NONE) return;
   if (*composite == GRPC_ERROR_NONE) {
     *composite = GRPC_ERROR_CREATE_FROM_STATIC_STRING("pollset_work");
@@ -874,12 +873,12 @@ static void work_combine_error(grpc_error **composite, grpc_error *error) {
   *composite = grpc_error_add_child(*composite, error);
 }
 
-static grpc_error *pollset_work(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
-                                grpc_pollset_worker **worker_hdl,
-                                gpr_timespec now, gpr_timespec deadline) {
+static grpc_error* pollset_work(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
+                                grpc_pollset_worker** worker_hdl,
+                                grpc_millis deadline) {
   grpc_pollset_worker worker;
   if (worker_hdl) *worker_hdl = &worker;
-  grpc_error *error = GRPC_ERROR_NONE;
+  grpc_error* error = GRPC_ERROR_NONE;
 
   /* Avoid malloc for small number of elements. */
   enum { inline_elements = 96 };
@@ -893,14 +892,14 @@ static grpc_error *pollset_work(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
   int keep_polling = 0;
   GPR_TIMER_BEGIN("pollset_work", 0);
   /* this must happen before we (potentially) drop pollset->mu */
-  worker.next = worker.prev = NULL;
+  worker.next = worker.prev = nullptr;
   worker.reevaluate_polling_on_wakeup = 0;
-  if (pollset->local_wakeup_cache != NULL) {
+  if (pollset->local_wakeup_cache != nullptr) {
     worker.wakeup_fd = pollset->local_wakeup_cache;
     pollset->local_wakeup_cache = worker.wakeup_fd->next;
   } else {
     worker.wakeup_fd =
-        (grpc_cached_wakeup_fd *)gpr_malloc(sizeof(*worker.wakeup_fd));
+        (grpc_cached_wakeup_fd*)gpr_malloc(sizeof(*worker.wakeup_fd));
     error = grpc_wakeup_fd_init(&worker.wakeup_fd->fd);
     if (error != GRPC_ERROR_NONE) {
       GRPC_LOG_IF_ERROR("pollset_work", GRPC_ERROR_REF(error));
@@ -942,10 +941,10 @@ static grpc_error *pollset_work(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
       int r;
       size_t i, fd_count;
       nfds_t pfd_count;
-      grpc_fd_watcher *watchers;
-      struct pollfd *pfds;
+      grpc_fd_watcher* watchers;
+      struct pollfd* pfds;
 
-      timeout = poll_deadline_to_millis_timeout(deadline, now);
+      timeout = poll_deadline_to_millis_timeout(exec_ctx, deadline);
 
       if (pollset->fd_count + 2 <= inline_elements) {
         pfds = pollfd_space;
@@ -954,9 +953,9 @@ static grpc_error *pollset_work(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
         /* Allocate one buffer to hold both pfds and watchers arrays */
         const size_t pfd_size = sizeof(*pfds) * (pollset->fd_count + 2);
         const size_t watch_size = sizeof(*watchers) * (pollset->fd_count + 2);
-        void *buf = gpr_malloc(pfd_size + watch_size);
-        pfds = (struct pollfd *)buf;
-        watchers = (grpc_fd_watcher *)(void *)((char *)buf + pfd_size);
+        void* buf = gpr_malloc(pfd_size + watch_size);
+        pfds = (struct pollfd*)buf;
+        watchers = (grpc_fd_watcher*)(void*)((char*)buf + pfd_size);
       }
 
       fd_count = 0;
@@ -980,7 +979,7 @@ static grpc_error *pollset_work(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
       gpr_mu_unlock(&pollset->mu);
 
       for (i = 1; i < pfd_count; i++) {
-        grpc_fd *fd = watchers[i].fd;
+        grpc_fd* fd = watchers[i].fd;
         pfds[i].events = (short)fd_begin_poll(fd, pollset, &worker, POLLIN,
                                               POLLOUT, &watchers[i]);
         GRPC_FD_UNREF(fd, "multipoller_start");
@@ -991,9 +990,9 @@ static grpc_error *pollset_work(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
       GRPC_SCHEDULING_START_BLOCKING_REGION;
       GRPC_STATS_INC_SYSCALL_POLL(exec_ctx);
       r = grpc_poll_function(pfds, pfd_count, timeout);
-      GRPC_SCHEDULING_END_BLOCKING_REGION;
+      GRPC_SCHEDULING_END_BLOCKING_REGION_WITH_EXEC_CTX(exec_ctx);
 
-      if (GRPC_TRACER_ON(grpc_polling_trace)) {
+      if (grpc_polling_trace.enabled()) {
         gpr_log(GPR_DEBUG, "%p poll=%d", pollset, r);
       }
 
@@ -1003,8 +1002,8 @@ static grpc_error *pollset_work(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
         }
 
         for (i = 1; i < pfd_count; i++) {
-          if (watchers[i].fd == NULL) {
-            fd_end_poll(exec_ctx, &watchers[i], 0, 0, NULL);
+          if (watchers[i].fd == nullptr) {
+            fd_end_poll(exec_ctx, &watchers[i], 0, 0, nullptr);
           } else {
             // Wake up all the file descriptors, if we have an invalid one
             // we can identify it on the next pollset_work()
@@ -1013,21 +1012,21 @@ static grpc_error *pollset_work(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
         }
       } else if (r == 0) {
         for (i = 1; i < pfd_count; i++) {
-          fd_end_poll(exec_ctx, &watchers[i], 0, 0, NULL);
+          fd_end_poll(exec_ctx, &watchers[i], 0, 0, nullptr);
         }
       } else {
         if (pfds[0].revents & POLLIN_CHECK) {
-          if (GRPC_TRACER_ON(grpc_polling_trace)) {
+          if (grpc_polling_trace.enabled()) {
             gpr_log(GPR_DEBUG, "%p: got_wakeup", pollset);
           }
           work_combine_error(
               &error, grpc_wakeup_fd_consume_wakeup(&worker.wakeup_fd->fd));
         }
         for (i = 1; i < pfd_count; i++) {
-          if (watchers[i].fd == NULL) {
-            fd_end_poll(exec_ctx, &watchers[i], 0, 0, NULL);
+          if (watchers[i].fd == nullptr) {
+            fd_end_poll(exec_ctx, &watchers[i], 0, 0, nullptr);
           } else {
-            if (GRPC_TRACER_ON(grpc_polling_trace)) {
+            if (grpc_polling_trace.enabled()) {
               gpr_log(GPR_DEBUG, "%p got_event: %d r:%d w:%d [%d]", pollset,
                       pfds[i].fd, (pfds[i].revents & POLLIN_CHECK) != 0,
                       (pfds[i].revents & POLLOUT_CHECK) != 0, pfds[i].revents);
@@ -1068,13 +1067,10 @@ static grpc_error *pollset_work(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
       if (queued_work || worker.kicked_specifically) {
         /* If there's queued work on the list, then set the deadline to be
            immediate so we get back out of the polling loop quickly */
-        deadline = gpr_inf_past(GPR_CLOCK_MONOTONIC);
+        deadline = 0;
       }
       keep_polling = 1;
     }
-    if (keep_polling) {
-      now = gpr_now(now.clock_type);
-    }
   }
   gpr_tls_set(&g_current_thread_poller, 0);
   if (added_worker) {
@@ -1087,7 +1083,7 @@ static grpc_error *pollset_work(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
   /* check shutdown conditions */
   if (pollset->shutting_down) {
     if (pollset_has_workers(pollset)) {
-      pollset_kick(exec_ctx, pollset, NULL);
+      pollset_kick(exec_ctx, pollset, nullptr);
     } else if (!pollset->called_shutdown && !pollset_has_observers(pollset)) {
       pollset->called_shutdown = 1;
       gpr_mu_unlock(&pollset->mu);
@@ -1105,14 +1101,14 @@ static grpc_error *pollset_work(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
       gpr_mu_lock(&pollset->mu);
     }
   }
-  if (worker_hdl) *worker_hdl = NULL;
+  if (worker_hdl) *worker_hdl = nullptr;
   GPR_TIMER_END("pollset_work", 0);
   GRPC_LOG_IF_ERROR("pollset_work", GRPC_ERROR_REF(error));
   return error;
 }
 
-static void pollset_shutdown(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
-                             grpc_closure *closure) {
+static void pollset_shutdown(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
+                             grpc_closure* closure) {
   GPR_ASSERT(!pollset->shutting_down);
   pollset->shutting_down = 1;
   pollset->shutdown_done = closure;
@@ -1126,43 +1122,36 @@ static void pollset_shutdown(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
   }
 }
 
-static int poll_deadline_to_millis_timeout(gpr_timespec deadline,
-                                           gpr_timespec now) {
-  gpr_timespec timeout;
-  static const int64_t max_spin_polling_us = 10;
-  if (gpr_time_cmp(deadline, gpr_inf_future(deadline.clock_type)) == 0) {
-    return -1;
-  }
-  if (gpr_time_cmp(deadline, gpr_time_add(now, gpr_time_from_micros(
-                                                   max_spin_polling_us,
-                                                   GPR_TIMESPAN))) <= 0) {
-    return 0;
-  }
-  timeout = gpr_time_sub(deadline, now);
-  return gpr_time_to_millis(gpr_time_add(
-      timeout, gpr_time_from_nanos(GPR_NS_PER_MS - 1, GPR_TIMESPAN)));
+static int poll_deadline_to_millis_timeout(grpc_exec_ctx* exec_ctx,
+                                           grpc_millis deadline) {
+  if (deadline == GRPC_MILLIS_INF_FUTURE) return -1;
+  if (deadline == 0) return 0;
+  grpc_millis n = deadline - grpc_exec_ctx_now(exec_ctx);
+  if (n < 0) return 0;
+  if (n > INT_MAX) return -1;
+  return (int)n;
 }
 
 /*******************************************************************************
  * pollset_set_posix.c
  */
 
-static grpc_pollset_set *pollset_set_create(void) {
-  grpc_pollset_set *pollset_set =
-      (grpc_pollset_set *)gpr_zalloc(sizeof(*pollset_set));
+static grpc_pollset_set* pollset_set_create(void) {
+  grpc_pollset_set* pollset_set =
+      (grpc_pollset_set*)gpr_zalloc(sizeof(*pollset_set));
   gpr_mu_init(&pollset_set->mu);
   return pollset_set;
 }
 
-static void pollset_set_destroy(grpc_exec_ctx *exec_ctx,
-                                grpc_pollset_set *pollset_set) {
+static void pollset_set_destroy(grpc_exec_ctx* exec_ctx,
+                                grpc_pollset_set* pollset_set) {
   size_t i;
   gpr_mu_destroy(&pollset_set->mu);
   for (i = 0; i < pollset_set->fd_count; i++) {
     GRPC_FD_UNREF(pollset_set->fds[i], "pollset_set");
   }
   for (i = 0; i < pollset_set->pollset_count; i++) {
-    grpc_pollset *pollset = pollset_set->pollsets[i];
+    grpc_pollset* pollset = pollset_set->pollsets[i];
     gpr_mu_lock(&pollset->mu);
     pollset->pollset_set_count--;
     /* check shutdown */
@@ -1181,9 +1170,9 @@ static void pollset_set_destroy(grpc_exec_ctx *exec_ctx,
   gpr_free(pollset_set);
 }
 
-static void pollset_set_add_pollset(grpc_exec_ctx *exec_ctx,
-                                    grpc_pollset_set *pollset_set,
-                                    grpc_pollset *pollset) {
+static void pollset_set_add_pollset(grpc_exec_ctx* exec_ctx,
+                                    grpc_pollset_set* pollset_set,
+                                    grpc_pollset* pollset) {
   size_t i, j;
   gpr_mu_lock(&pollset->mu);
   pollset->pollset_set_count++;
@@ -1192,7 +1181,7 @@ static void pollset_set_add_pollset(grpc_exec_ctx *exec_ctx,
   if (pollset_set->pollset_count == pollset_set->pollset_capacity) {
     pollset_set->pollset_capacity =
         GPR_MAX(8, 2 * pollset_set->pollset_capacity);
-    pollset_set->pollsets = (grpc_pollset **)gpr_realloc(
+    pollset_set->pollsets = (grpc_pollset**)gpr_realloc(
         pollset_set->pollsets,
         pollset_set->pollset_capacity * sizeof(*pollset_set->pollsets));
   }
@@ -1209,15 +1198,15 @@ static void pollset_set_add_pollset(grpc_exec_ctx *exec_ctx,
   gpr_mu_unlock(&pollset_set->mu);
 }
 
-static void pollset_set_del_pollset(grpc_exec_ctx *exec_ctx,
-                                    grpc_pollset_set *pollset_set,
-                                    grpc_pollset *pollset) {
+static void pollset_set_del_pollset(grpc_exec_ctx* exec_ctx,
+                                    grpc_pollset_set* pollset_set,
+                                    grpc_pollset* pollset) {
   size_t i;
   gpr_mu_lock(&pollset_set->mu);
   for (i = 0; i < pollset_set->pollset_count; i++) {
     if (pollset_set->pollsets[i] == pollset) {
       pollset_set->pollset_count--;
-      GPR_SWAP(grpc_pollset *, pollset_set->pollsets[i],
+      GPR_SWAP(grpc_pollset*, pollset_set->pollsets[i],
                pollset_set->pollsets[pollset_set->pollset_count]);
       break;
     }
@@ -1236,14 +1225,14 @@ static void pollset_set_del_pollset(grpc_exec_ctx *exec_ctx,
   }
 }
 
-static void pollset_set_add_pollset_set(grpc_exec_ctx *exec_ctx,
-                                        grpc_pollset_set *bag,
-                                        grpc_pollset_set *item) {
+static void pollset_set_add_pollset_set(grpc_exec_ctx* exec_ctx,
+                                        grpc_pollset_set* bag,
+                                        grpc_pollset_set* item) {
   size_t i, j;
   gpr_mu_lock(&bag->mu);
   if (bag->pollset_set_count == bag->pollset_set_capacity) {
     bag->pollset_set_capacity = GPR_MAX(8, 2 * bag->pollset_set_capacity);
-    bag->pollset_sets = (grpc_pollset_set **)gpr_realloc(
+    bag->pollset_sets = (grpc_pollset_set**)gpr_realloc(
         bag->pollset_sets,
         bag->pollset_set_capacity * sizeof(*bag->pollset_sets));
   }
@@ -1260,15 +1249,15 @@ static void pollset_set_add_pollset_set(grpc_exec_ctx *exec_ctx,
   gpr_mu_unlock(&bag->mu);
 }
 
-static void pollset_set_del_pollset_set(grpc_exec_ctx *exec_ctx,
-                                        grpc_pollset_set *bag,
-                                        grpc_pollset_set *item) {
+static void pollset_set_del_pollset_set(grpc_exec_ctx* exec_ctx,
+                                        grpc_pollset_set* bag,
+                                        grpc_pollset_set* item) {
   size_t i;
   gpr_mu_lock(&bag->mu);
   for (i = 0; i < bag->pollset_set_count; i++) {
     if (bag->pollset_sets[i] == item) {
       bag->pollset_set_count--;
-      GPR_SWAP(grpc_pollset_set *, bag->pollset_sets[i],
+      GPR_SWAP(grpc_pollset_set*, bag->pollset_sets[i],
                bag->pollset_sets[bag->pollset_set_count]);
       break;
     }
@@ -1276,13 +1265,13 @@ static void pollset_set_del_pollset_set(grpc_exec_ctx *exec_ctx,
   gpr_mu_unlock(&bag->mu);
 }
 
-static void pollset_set_add_fd(grpc_exec_ctx *exec_ctx,
-                               grpc_pollset_set *pollset_set, grpc_fd *fd) {
+static void pollset_set_add_fd(grpc_exec_ctx* exec_ctx,
+                               grpc_pollset_set* pollset_set, grpc_fd* fd) {
   size_t i;
   gpr_mu_lock(&pollset_set->mu);
   if (pollset_set->fd_count == pollset_set->fd_capacity) {
     pollset_set->fd_capacity = GPR_MAX(8, 2 * pollset_set->fd_capacity);
-    pollset_set->fds = (grpc_fd **)gpr_realloc(
+    pollset_set->fds = (grpc_fd**)gpr_realloc(
         pollset_set->fds, pollset_set->fd_capacity * sizeof(*pollset_set->fds));
   }
   GRPC_FD_REF(fd, "pollset_set");
@@ -1296,14 +1285,14 @@ static void pollset_set_add_fd(grpc_exec_ctx *exec_ctx,
   gpr_mu_unlock(&pollset_set->mu);
 }
 
-static void pollset_set_del_fd(grpc_exec_ctx *exec_ctx,
-                               grpc_pollset_set *pollset_set, grpc_fd *fd) {
+static void pollset_set_del_fd(grpc_exec_ctx* exec_ctx,
+                               grpc_pollset_set* pollset_set, grpc_fd* fd) {
   size_t i;
   gpr_mu_lock(&pollset_set->mu);
   for (i = 0; i < pollset_set->fd_count; i++) {
     if (pollset_set->fds[i] == fd) {
       pollset_set->fd_count--;
-      GPR_SWAP(grpc_fd *, pollset_set->fds[i],
+      GPR_SWAP(grpc_fd*, pollset_set->fds[i],
                pollset_set->fds[pollset_set->fd_count]);
       GRPC_FD_UNREF(fd, "pollset_set");
       break;
@@ -1319,10 +1308,10 @@ static void pollset_set_del_fd(grpc_exec_ctx *exec_ctx,
  * Condition Variable polling extensions
  */
 
-static void run_poll(void *args);
-static void cache_poller_locked(poll_args *args);
+static void run_poll(void* args);
+static void cache_poller_locked(poll_args* args);
 
-static void cache_insert_locked(poll_args *args) {
+static void cache_insert_locked(poll_args* args) {
   uint32_t key = gpr_murmur_hash3(args->fds, args->nfds * sizeof(struct pollfd),
                                   0xDEADBEEF);
   key = key % poll_cache.size;
@@ -1330,18 +1319,18 @@ static void cache_insert_locked(poll_args *args) {
     poll_cache.active_pollers[key]->prev = args;
   }
   args->next = poll_cache.active_pollers[key];
-  args->prev = NULL;
+  args->prev = nullptr;
   poll_cache.active_pollers[key] = args;
   poll_cache.count++;
 }
 
-static void init_result(poll_args *pargs) {
-  pargs->result = (poll_result *)gpr_malloc(sizeof(poll_result));
+static void init_result(poll_args* pargs) {
+  pargs->result = (poll_result*)gpr_malloc(sizeof(poll_result));
   gpr_ref_init(&pargs->result->refcount, 1);
-  pargs->result->watchers = NULL;
+  pargs->result->watchers = nullptr;
   pargs->result->watchcount = 0;
   pargs->result->fds =
-      (struct pollfd *)gpr_malloc(sizeof(struct pollfd) * pargs->nfds);
+      (struct pollfd*)gpr_malloc(sizeof(struct pollfd) * pargs->nfds);
   memcpy(pargs->result->fds, pargs->fds, sizeof(struct pollfd) * pargs->nfds);
   pargs->result->nfds = pargs->nfds;
   pargs->result->retval = 0;
@@ -1351,11 +1340,11 @@ static void init_result(poll_args *pargs) {
 
 // Creates a poll_args object for a given arguments to poll().
 // This object may return a poll_args in the cache.
-static poll_args *get_poller_locked(struct pollfd *fds, nfds_t count) {
+static poll_args* get_poller_locked(struct pollfd* fds, nfds_t count) {
   uint32_t key =
       gpr_murmur_hash3(fds, count * sizeof(struct pollfd), 0xDEADBEEF);
   key = key % poll_cache.size;
-  poll_args *curr = poll_cache.active_pollers[key];
+  poll_args* curr = poll_cache.active_pollers[key];
   while (curr) {
     if (curr->nfds == count &&
         memcmp(curr->fds, fds, count * sizeof(struct pollfd)) == 0) {
@@ -1366,26 +1355,26 @@ static poll_args *get_poller_locked(struct pollfd *fds, nfds_t count) {
   }
 
   if (poll_cache.free_pollers) {
-    poll_args *pargs = poll_cache.free_pollers;
+    poll_args* pargs = poll_cache.free_pollers;
     poll_cache.free_pollers = pargs->next;
     if (poll_cache.free_pollers) {
-      poll_cache.free_pollers->prev = NULL;
+      poll_cache.free_pollers->prev = nullptr;
     }
     pargs->fds = fds;
     pargs->nfds = count;
-    pargs->next = NULL;
-    pargs->prev = NULL;
+    pargs->next = nullptr;
+    pargs->prev = nullptr;
     init_result(pargs);
     cache_poller_locked(pargs);
     return pargs;
   }
 
-  poll_args *pargs = (poll_args *)gpr_malloc(sizeof(struct poll_args));
+  poll_args* pargs = (poll_args*)gpr_malloc(sizeof(struct poll_args));
   gpr_cv_init(&pargs->trigger);
   pargs->fds = fds;
   pargs->nfds = count;
-  pargs->next = NULL;
-  pargs->prev = NULL;
+  pargs->next = nullptr;
+  pargs->prev = nullptr;
   pargs->trigger_set = 0;
   init_result(pargs);
   cache_poller_locked(pargs);
@@ -1397,7 +1386,7 @@ static poll_args *get_poller_locked(struct pollfd *fds, nfds_t count) {
   return pargs;
 }
 
-static void cache_delete_locked(poll_args *args) {
+static void cache_delete_locked(poll_args* args) {
   if (!args->prev) {
     uint32_t key = gpr_murmur_hash3(
         args->fds, args->nfds * sizeof(struct pollfd), 0xDEADBEEF);
@@ -1416,25 +1405,25 @@ static void cache_delete_locked(poll_args *args) {
   if (poll_cache.free_pollers) {
     poll_cache.free_pollers->prev = args;
   }
-  args->prev = NULL;
+  args->prev = nullptr;
   args->next = poll_cache.free_pollers;
   gpr_free(args->fds);
   poll_cache.free_pollers = args;
 }
 
-static void cache_poller_locked(poll_args *args) {
+static void cache_poller_locked(poll_args* args) {
   if (poll_cache.count + 1 > poll_cache.size / 2) {
-    poll_args **old_active_pollers = poll_cache.active_pollers;
+    poll_args** old_active_pollers = poll_cache.active_pollers;
     poll_cache.size = poll_cache.size * 2;
     poll_cache.count = 0;
     poll_cache.active_pollers =
-        (poll_args **)gpr_malloc(sizeof(void *) * poll_cache.size);
+        (poll_args**)gpr_malloc(sizeof(void*) * poll_cache.size);
     for (unsigned int i = 0; i < poll_cache.size; i++) {
-      poll_cache.active_pollers[i] = NULL;
+      poll_cache.active_pollers[i] = nullptr;
     }
     for (unsigned int i = 0; i < poll_cache.size / 2; i++) {
-      poll_args *curr = old_active_pollers[i];
-      poll_args *next = NULL;
+      poll_args* curr = old_active_pollers[i];
+      poll_args* next = nullptr;
       while (curr) {
         next = curr->next;
         cache_insert_locked(curr);
@@ -1447,7 +1436,7 @@ static void cache_poller_locked(poll_args *args) {
   cache_insert_locked(args);
 }
 
-static void cache_destroy_locked(poll_args *args) {
+static void cache_destroy_locked(poll_args* args) {
   if (args->next) {
     args->next->prev = args->prev;
   }
@@ -1461,7 +1450,7 @@ static void cache_destroy_locked(poll_args *args) {
   gpr_free(args);
 }
 
-static void decref_poll_result(poll_result *res) {
+static void decref_poll_result(poll_result* res) {
   if (gpr_unref(&res->refcount)) {
     GPR_ASSERT(!res->watchers);
     gpr_free(res->fds);
@@ -1469,7 +1458,7 @@ static void decref_poll_result(poll_result *res) {
   }
 }
 
-void remove_cvn(cv_node **head, cv_node *target) {
+void remove_cvn(cv_node** head, cv_node* target) {
   if (target->next) {
     target->next->prev = target->prev;
   }
@@ -1484,17 +1473,17 @@ void remove_cvn(cv_node **head, cv_node *target) {
 gpr_timespec thread_grace;
 
 // Poll in a background thread
-static void run_poll(void *args) {
-  poll_args *pargs = (poll_args *)args;
+static void run_poll(void* args) {
+  poll_args* pargs = (poll_args*)args;
   while (1) {
-    poll_result *result = pargs->result;
+    poll_result* result = pargs->result;
     int retval = g_cvfds.poll(result->fds, result->nfds, CV_POLL_PERIOD_MS);
     gpr_mu_lock(&g_cvfds.mu);
     if (retval != 0) {
       result->completed = 1;
       result->retval = retval;
       result->err = errno;
-      cv_node *watcher = result->watchers;
+      cv_node* watcher = result->watchers;
       while (watcher) {
         gpr_cv_signal(watcher->cv);
         watcher = watcher->next;
@@ -1525,27 +1514,27 @@ static void run_poll(void *args) {
 }
 
 // This function overrides poll() to handle condition variable wakeup fds
-static int cvfd_poll(struct pollfd *fds, nfds_t nfds, int timeout) {
+static int cvfd_poll(struct pollfd* fds, nfds_t nfds, int timeout) {
   unsigned int i;
   int res, idx;
-  cv_node *pollcv;
+  cv_node* pollcv;
   int skip_poll = 0;
   nfds_t nsockfds = 0;
-  poll_result *result = NULL;
+  poll_result* result = nullptr;
   gpr_mu_lock(&g_cvfds.mu);
-  pollcv = (cv_node *)gpr_malloc(sizeof(cv_node));
-  pollcv->next = NULL;
+  pollcv = (cv_node*)gpr_malloc(sizeof(cv_node));
+  pollcv->next = nullptr;
   gpr_cv pollcv_cv;
   gpr_cv_init(&pollcv_cv);
   pollcv->cv = &pollcv_cv;
-  cv_node *fd_cvs = (cv_node *)gpr_malloc(nfds * sizeof(cv_node));
+  cv_node* fd_cvs = (cv_node*)gpr_malloc(nfds * sizeof(cv_node));
 
   for (i = 0; i < nfds; i++) {
     fds[i].revents = 0;
     if (fds[i].fd < 0 && (fds[i].events & POLLIN)) {
       idx = GRPC_FD_TO_IDX(fds[i].fd);
       fd_cvs[i].cv = &pollcv_cv;
-      fd_cvs[i].prev = NULL;
+      fd_cvs[i].prev = nullptr;
       fd_cvs[i].next = g_cvfds.cvfds[idx].cvs;
       if (g_cvfds.cvfds[idx].cvs) {
         g_cvfds.cvfds[idx].cvs->prev = &(fd_cvs[i]);
@@ -1570,8 +1559,8 @@ static int cvfd_poll(struct pollfd *fds, nfds_t nfds, int timeout) {
 
   res = 0;
   if (!skip_poll && nsockfds > 0) {
-    struct pollfd *pollfds =
-        (struct pollfd *)gpr_malloc(sizeof(struct pollfd) * nsockfds);
+    struct pollfd* pollfds =
+        (struct pollfd*)gpr_malloc(sizeof(struct pollfd) * nsockfds);
     idx = 0;
     for (i = 0; i < nfds; i++) {
       if (fds[i].fd >= 0) {
@@ -1581,10 +1570,10 @@ static int cvfd_poll(struct pollfd *fds, nfds_t nfds, int timeout) {
         idx++;
       }
     }
-    poll_args *pargs = get_poller_locked(pollfds, nsockfds);
+    poll_args* pargs = get_poller_locked(pollfds, nsockfds);
     result = pargs->result;
     pollcv->next = result->watchers;
-    pollcv->prev = NULL;
+    pollcv->prev = nullptr;
     if (result->watchers) {
       result->watchers->prev = pollcv;
     }
@@ -1634,13 +1623,12 @@ static void global_cv_fd_table_init() {
   gpr_cv_init(&g_cvfds.shutdown_cv);
   gpr_ref_init(&g_cvfds.pollcount, 1);
   g_cvfds.size = CV_DEFAULT_TABLE_SIZE;
-  g_cvfds.cvfds =
-      (fd_node *)gpr_malloc(sizeof(fd_node) * CV_DEFAULT_TABLE_SIZE);
-  g_cvfds.free_fds = NULL;
+  g_cvfds.cvfds = (fd_node*)gpr_malloc(sizeof(fd_node) * CV_DEFAULT_TABLE_SIZE);
+  g_cvfds.free_fds = nullptr;
   thread_grace = gpr_time_from_millis(POLLCV_THREAD_GRACE_MS, GPR_TIMESPAN);
   for (int i = 0; i < CV_DEFAULT_TABLE_SIZE; i++) {
     g_cvfds.cvfds[i].is_set = 0;
-    g_cvfds.cvfds[i].cvs = NULL;
+    g_cvfds.cvfds[i].cvs = nullptr;
     g_cvfds.cvfds[i].next_free = g_cvfds.free_fds;
     g_cvfds.free_fds = &g_cvfds.cvfds[i];
   }
@@ -1651,10 +1639,10 @@ static void global_cv_fd_table_init() {
   // Initialize the cache
   poll_cache.size = 32;
   poll_cache.count = 0;
-  poll_cache.free_pollers = NULL;
-  poll_cache.active_pollers = (poll_args **)gpr_malloc(sizeof(void *) * 32);
+  poll_cache.free_pollers = nullptr;
+  poll_cache.active_pollers = (poll_args**)gpr_malloc(sizeof(void*) * 32);
   for (unsigned int i = 0; i < poll_cache.size; i++) {
-    poll_cache.active_pollers[i] = NULL;
+    poll_cache.active_pollers[i] = nullptr;
   }
 
   gpr_mu_unlock(&g_cvfds.mu);
@@ -1722,23 +1710,24 @@ static const grpc_event_engine_vtable vtable = {
     shutdown_engine,
 };
 
-const grpc_event_engine_vtable *grpc_init_poll_posix(bool explicit_request) {
+const grpc_event_engine_vtable* grpc_init_poll_posix(bool explicit_request) {
   if (!grpc_has_wakeup_fd()) {
-    return NULL;
+    gpr_log(GPR_ERROR, "Skipping poll because of no wakeup fd.");
+    return nullptr;
   }
   if (!GRPC_LOG_IF_ERROR("pollset_global_init", pollset_global_init())) {
-    return NULL;
+    return nullptr;
   }
   return &vtable;
 }
 
-const grpc_event_engine_vtable *grpc_init_poll_cv_posix(bool explicit_request) {
+const grpc_event_engine_vtable* grpc_init_poll_cv_posix(bool explicit_request) {
   global_cv_fd_table_init();
   grpc_enable_cv_wakeup_fds(1);
   if (!GRPC_LOG_IF_ERROR("pollset_global_init", pollset_global_init())) {
     global_cv_fd_table_shutdown();
     grpc_enable_cv_wakeup_fds(0);
-    return NULL;
+    return nullptr;
   }
   return &vtable;
 }