grpc 1.43.1 → 1.48.0

data/src/core/lib/iomgr/ev_posix.cc

@@ -18,6 +18,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <grpc/grpc.h>
+
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_POSIX_SOCKET_EV
@@ -32,7 +34,6 @@
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/global_config.h"
 #include "src/core/lib/iomgr/ev_epoll1_linux.h"
-#include "src/core/lib/iomgr/ev_epollex_linux.h"
 #include "src/core/lib/iomgr/ev_poll_posix.h"
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/internal_errqueue.h"
@@ -75,44 +76,7 @@ grpc_poll_function_type grpc_poll_function = aix_poll;
 grpc_wakeup_fd grpc_global_wakeup_fd;
 
 static const grpc_event_engine_vtable* g_event_engine = nullptr;
-static const char* g_poll_strategy_name = nullptr;
-
-typedef const grpc_event_engine_vtable* (*event_engine_factory_fn)(
-    bool explicit_request);
-
-struct event_engine_factory {
-  const char* name;
-  event_engine_factory_fn factory;
-};
-namespace {
-
-grpc_poll_function_type real_poll_function;
-
-int phony_poll(struct pollfd fds[], nfds_t nfds, int timeout) {
-  if (timeout == 0) {
-    return real_poll_function(fds, nfds, 0);
-  } else {
-    gpr_log(GPR_ERROR, "Attempted a blocking poll when declared non-polling.");
-    GPR_ASSERT(false);
-    return -1;
-  }
-}
-
-const grpc_event_engine_vtable* init_non_polling(bool explicit_request) {
-  if (!explicit_request) {
-    return nullptr;
-  }
-  // return the simplest engine as a phony but also override the poller
-  auto ret = grpc_init_poll_posix(explicit_request);
-  real_poll_function = grpc_poll_function;
-  grpc_poll_function = phony_poll;
-
-  return ret;
-}
-}  // namespace
-
-#define ENGINE_HEAD_CUSTOM "head_custom"
-#define ENGINE_TAIL_CUSTOM "tail_custom"
+static gpr_once g_choose_engine = GPR_ONCE_INIT;
 
 // The global array of event-engine factories. Each entry is a pair with a name
 // and an event-engine generator function (nullptr if there is no generator
@@ -125,13 +89,18 @@ const grpc_event_engine_vtable* init_non_polling(bool explicit_request) {
 // specific poller that is requested by name in the GRPC_POLL_STRATEGY
 // environment variable if that variable is set (which should be a
 // comma-separated list of one or more event engine names)
-static event_engine_factory g_factories[] = {
-    {ENGINE_HEAD_CUSTOM, nullptr},        {ENGINE_HEAD_CUSTOM, nullptr},
-    {ENGINE_HEAD_CUSTOM, nullptr},        {ENGINE_HEAD_CUSTOM, nullptr},
-    {"epollex", grpc_init_epollex_linux}, {"epoll1", grpc_init_epoll1_linux},
-    {"poll", grpc_init_poll_posix},       {"none", init_non_polling},
-    {ENGINE_TAIL_CUSTOM, nullptr},        {ENGINE_TAIL_CUSTOM, nullptr},
-    {ENGINE_TAIL_CUSTOM, nullptr},        {ENGINE_TAIL_CUSTOM, nullptr},
+static const grpc_event_engine_vtable* g_vtables[] = {
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    &grpc_ev_epoll1_posix,
+    &grpc_ev_poll_posix,
+    &grpc_ev_none_posix,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
 };
 
 static void add(const char* beg, const char* end, char*** ss, size_t* ns) {
@@ -164,84 +133,73 @@ static bool is(const char* want, const char* have) {
 }
 
 static void try_engine(const char* engine) {
-  for (size_t i = 0; i < GPR_ARRAY_SIZE(g_factories); i++) {
-    if (g_factories[i].factory != nullptr && is(engine, g_factories[i].name)) {
-      if ((g_event_engine = g_factories[i].factory(
-               0 == strcmp(engine, g_factories[i].name)))) {
-        g_poll_strategy_name = g_factories[i].name;
-        gpr_log(GPR_DEBUG, "Using polling engine: %s", g_factories[i].name);
-        return;
-      }
+  for (size_t i = 0; i < GPR_ARRAY_SIZE(g_vtables); i++) {
+    if (g_vtables[i] != nullptr && is(engine, g_vtables[i]->name) &&
+        g_vtables[i]->check_engine_available(
+            0 == strcmp(engine, g_vtables[i]->name))) {
+      g_event_engine = g_vtables[i];
+      gpr_log(GPR_DEBUG, "Using polling engine: %s", g_event_engine->name);
+      return;
     }
   }
 }
 
 /* Call this before calling grpc_event_engine_init() */
-void grpc_register_event_engine_factory(const char* name,
-                                        event_engine_factory_fn factory,
+void grpc_register_event_engine_factory(const grpc_event_engine_vtable* vtable,
                                         bool add_at_head) {
-  const char* custom_match =
-      add_at_head ? ENGINE_HEAD_CUSTOM : ENGINE_TAIL_CUSTOM;
+  const grpc_event_engine_vtable** first_null = nullptr;
+  const grpc_event_engine_vtable** last_null = nullptr;
 
   // Overwrite an existing registration if already registered
-  for (size_t i = 0; i < GPR_ARRAY_SIZE(g_factories); i++) {
-    if (0 == strcmp(name, g_factories[i].name)) {
-      g_factories[i].factory = factory;
+  for (size_t i = 0; i < GPR_ARRAY_SIZE(g_vtables); i++) {
+    if (g_vtables[i] == nullptr) {
+      if (first_null == nullptr) first_null = &g_vtables[i];
+      last_null = &g_vtables[i];
+    } else if (0 == strcmp(g_vtables[i]->name, vtable->name)) {
+      g_vtables[i] = vtable;
       return;
     }
   }
 
-  // Otherwise fill in an available custom slot
-  for (size_t i = 0; i < GPR_ARRAY_SIZE(g_factories); i++) {
-    if (0 == strcmp(g_factories[i].name, custom_match)) {
-      g_factories[i].name = name;
-      g_factories[i].factory = factory;
-      return;
-    }
-  }
-
-  // Otherwise fail
-  GPR_ASSERT(false);
+  *(add_at_head ? first_null : last_null) = vtable;
 }
 
 /*If grpc_event_engine_init() has been called, returns the poll_strategy_name.
  * Otherwise, returns nullptr. */
-const char* grpc_get_poll_strategy_name() { return g_poll_strategy_name; }
+const char* grpc_get_poll_strategy_name() { return g_event_engine->name; }
 
 void grpc_event_engine_init(void) {
-  grpc_core::UniquePtr<char> value = GPR_GLOBAL_CONFIG_GET(grpc_poll_strategy);
+  gpr_once_init(&g_choose_engine, []() {
+    grpc_core::UniquePtr<char> value =
+        GPR_GLOBAL_CONFIG_GET(grpc_poll_strategy);
 
-  char** strings = nullptr;
-  size_t nstrings = 0;
-  split(value.get(), &strings, &nstrings);
+    char** strings = nullptr;
+    size_t nstrings = 0;
+    split(value.get(), &strings, &nstrings);
 
-  for (size_t i = 0; g_event_engine == nullptr && i < nstrings; i++) {
-    try_engine(strings[i]);
-  }
+    for (size_t i = 0; g_event_engine == nullptr && i < nstrings; i++) {
+      try_engine(strings[i]);
+    }
 
-  for (size_t i = 0; i < nstrings; i++) {
-    gpr_free(strings[i]);
-  }
-  gpr_free(strings);
+    for (size_t i = 0; i < nstrings; i++) {
+      gpr_free(strings[i]);
+    }
+    gpr_free(strings);
 
-  if (g_event_engine == nullptr) {
-    gpr_log(GPR_ERROR, "No event engine could be initialized from %s",
-            value.get());
-    abort();
-  }
+    if (g_event_engine == nullptr) {
+      gpr_log(GPR_ERROR, "No event engine could be initialized from %s",
+              value.get());
+      abort();
+    }
+  });
+  g_event_engine->init_engine();
 }
 
-void grpc_event_engine_shutdown(void) {
-  g_event_engine->shutdown_engine();
-  g_event_engine = nullptr;
-}
+void grpc_event_engine_shutdown(void) { g_event_engine->shutdown_engine(); }
 
 bool grpc_event_engine_can_track_errors(void) {
   /* Only track errors if platform supports errqueue. */
-  if (grpc_core::kernel_supports_errqueue()) {
-    return g_event_engine->can_track_err;
-  }
-  return false;
+  return grpc_core::KernelSupportsErrqueue() && g_event_engine->can_track_err;
 }
 
 bool grpc_event_engine_run_in_background(void) {
@@ -316,13 +274,13 @@ static void pollset_destroy(grpc_pollset* pollset) {
 
 static grpc_error_handle pollset_work(grpc_pollset* pollset,
                                       grpc_pollset_worker** worker,
-                                      grpc_millis deadline) {
+                                      grpc_core::Timestamp deadline) {
   GRPC_POLLING_API_TRACE("pollset_work(%p, %" PRId64 ") begin", pollset,
-                         deadline);
+                         deadline.milliseconds_after_process_epoch());
   grpc_error_handle err =
       g_event_engine->pollset_work(pollset, worker, deadline);
   GRPC_POLLING_API_TRACE("pollset_work(%p, %" PRId64 ") end", pollset,
-                         deadline);
+                         deadline.milliseconds_after_process_epoch());
   return err;
 }
 

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

@@ -66,7 +66,7 @@ typedef struct grpc_event_engine_vtable {
   void (*pollset_destroy)(grpc_pollset* pollset);
   grpc_error_handle (*pollset_work)(grpc_pollset* pollset,
                                     grpc_pollset_worker** worker,
-                                    grpc_millis deadline);
+                                    grpc_core::Timestamp deadline);
   grpc_error_handle (*pollset_kick)(grpc_pollset* pollset,
                                     grpc_pollset_worker* specific_worker);
   void (*pollset_add_fd)(grpc_pollset* pollset, struct grpc_fd* fd);
@@ -85,6 +85,9 @@ typedef struct grpc_event_engine_vtable {
   void (*pollset_set_del_fd)(grpc_pollset_set* pollset_set, grpc_fd* fd);
 
   bool (*is_any_background_poller_thread)(void);
+  const char* name;
+  bool (*check_engine_available)(bool explicit_request);
+  void (*init_engine)();
   void (*shutdown_background_closure)(void);
   void (*shutdown_engine)(void);
   bool (*add_closure_to_background_poller)(grpc_closure* closure,
@@ -92,9 +95,8 @@ typedef struct grpc_event_engine_vtable {
 } grpc_event_engine_vtable;
 
 /* register a new event engine factory */
-void grpc_register_event_engine_factory(
-    const char* name, const grpc_event_engine_vtable* (*factory)(bool),
-    bool add_at_head);
+void grpc_register_event_engine_factory(const grpc_event_engine_vtable* vtable,
+                                        bool add_at_head);
 
 void grpc_event_engine_init(void);
 void grpc_event_engine_shutdown(void);

data/src/core/lib/iomgr/exec_ctx.cc

@@ -27,7 +27,7 @@
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/profiling/timers.h"
 
-static void exec_ctx_run(grpc_closure* closure, grpc_error_handle error) {
+static void exec_ctx_run(grpc_closure* closure) {
 #ifndef NDEBUG
   closure->scheduled = false;
   if (grpc_trace_closure.enabled()) {
@@ -37,111 +37,35 @@ static void exec_ctx_run(grpc_closure* closure, grpc_error_handle error) {
             closure->line_initiated);
   }
 #endif
+#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
+  grpc_error_handle error =
+      grpc_core::internal::StatusMoveFromHeapPtr(closure->error_data.error);
+  closure->error_data.error = 0;
+  closure->cb(closure->cb_arg, std::move(error));
+#else
+  grpc_error_handle error =
+      reinterpret_cast<grpc_error_handle>(closure->error_data.error);
+  closure->error_data.error = 0;
   closure->cb(closure->cb_arg, error);
+  GRPC_ERROR_UNREF(error);
+#endif
 #ifndef NDEBUG
   if (grpc_trace_closure.enabled()) {
     gpr_log(GPR_DEBUG, "closure %p finished", closure);
   }
 #endif
-  GRPC_ERROR_UNREF(error);
-}
-
-static void exec_ctx_sched(grpc_closure* closure, grpc_error_handle error) {
-  grpc_closure_list_append(grpc_core::ExecCtx::Get()->closure_list(), closure,
-                           error);
-}
-
-static gpr_timespec g_start_time;
-static gpr_cycle_counter g_start_cycle;
-
-static grpc_millis timespan_to_millis_round_down(gpr_timespec ts) {
-  double x = GPR_MS_PER_SEC * static_cast<double>(ts.tv_sec) +
-             static_cast<double>(ts.tv_nsec) / GPR_NS_PER_MS;
-  if (x < 0) return 0;
-  if (x > static_cast<double>(GRPC_MILLIS_INF_FUTURE)) {
-    return GRPC_MILLIS_INF_FUTURE;
-  }
-  return static_cast<grpc_millis>(x);
-}
-
-static grpc_millis timespec_to_millis_round_down(gpr_timespec ts) {
-  return timespan_to_millis_round_down(gpr_time_sub(ts, g_start_time));
-}
-
-static grpc_millis timespan_to_millis_round_up(gpr_timespec ts) {
-  double x = GPR_MS_PER_SEC * static_cast<double>(ts.tv_sec) +
-             static_cast<double>(ts.tv_nsec) / GPR_NS_PER_MS +
-             static_cast<double>(GPR_NS_PER_SEC - 1) /
-                 static_cast<double>(GPR_NS_PER_SEC);
-  if (x < 0) return 0;
-  if (x > static_cast<double>(GRPC_MILLIS_INF_FUTURE)) {
-    return GRPC_MILLIS_INF_FUTURE;
-  }
-  return static_cast<grpc_millis>(x);
-}
-
-static grpc_millis timespec_to_millis_round_up(gpr_timespec ts) {
-  return timespan_to_millis_round_up(gpr_time_sub(ts, g_start_time));
-}
-
-gpr_timespec grpc_millis_to_timespec(grpc_millis millis,
-                                     gpr_clock_type clock_type) {
-  // special-case infinities as grpc_millis can be 32bit on some platforms
-  // while gpr_time_from_millis always takes an int64_t.
-  if (millis == GRPC_MILLIS_INF_FUTURE) {
-    return gpr_inf_future(clock_type);
-  }
-  if (millis == GRPC_MILLIS_INF_PAST) {
-    return gpr_inf_past(clock_type);
-  }
-
-  if (clock_type == GPR_TIMESPAN) {
-    return gpr_time_from_millis(millis, GPR_TIMESPAN);
-  }
-  return gpr_time_add(gpr_convert_clock_type(g_start_time, clock_type),
-                      gpr_time_from_millis(millis, GPR_TIMESPAN));
-}
-
-grpc_millis grpc_timespec_to_millis_round_down(gpr_timespec ts) {
-  return timespec_to_millis_round_down(
-      gpr_convert_clock_type(ts, g_start_time.clock_type));
-}
-
-grpc_millis grpc_timespec_to_millis_round_up(gpr_timespec ts) {
-  return timespec_to_millis_round_up(
-      gpr_convert_clock_type(ts, g_start_time.clock_type));
 }
 
-grpc_millis grpc_cycle_counter_to_millis_round_down(gpr_cycle_counter cycles) {
-  return timespan_to_millis_round_down(
-      gpr_cycle_counter_sub(cycles, g_start_cycle));
-}
-
-grpc_millis grpc_cycle_counter_to_millis_round_up(gpr_cycle_counter cycles) {
-  return timespan_to_millis_round_up(
-      gpr_cycle_counter_sub(cycles, g_start_cycle));
+static void exec_ctx_sched(grpc_closure* closure) {
+  grpc_closure_list_append(grpc_core::ExecCtx::Get()->closure_list(), closure);
 }
 
 namespace grpc_core {
+
 GPR_THREAD_LOCAL(ExecCtx*) ExecCtx::exec_ctx_;
 GPR_THREAD_LOCAL(ApplicationCallbackExecCtx*)
 ApplicationCallbackExecCtx::callback_exec_ctx_;
 
-// WARNING: for testing purposes only!
-void ExecCtx::TestOnlyGlobalInit(gpr_timespec new_val) {
-  g_start_time = new_val;
-}
-
-void ExecCtx::GlobalInit(void) {
-  // gpr_now(GPR_CLOCK_MONOTONIC) incurs a syscall. We don't actually know the
-  // exact cycle the time was captured, so we use the average of cycles before
-  // and after the syscall as the starting cycle.
-  const gpr_cycle_counter cycle_before = gpr_get_cycle_counter();
-  g_start_time = gpr_now(GPR_CLOCK_MONOTONIC);
-  const gpr_cycle_counter cycle_after = gpr_get_cycle_counter();
-  g_start_cycle = (cycle_before + cycle_after) / 2;
-}
-
 bool ExecCtx::Flush() {
   bool did_something = false;
   GPR_TIMER_SCOPE("grpc_exec_ctx_flush", 0);
@@ -151,9 +75,8 @@ bool ExecCtx::Flush() {
       closure_list_.head = closure_list_.tail = nullptr;
       while (c != nullptr) {
         grpc_closure* next = c->next_data.next;
-        grpc_error_handle error = c->error_data.error;
         did_something = true;
-        exec_ctx_run(c, error);
+        exec_ctx_run(c);
         c = next;
       }
     } else if (!grpc_combiner_continue_exec_ctx()) {
@@ -164,9 +87,9 @@ bool ExecCtx::Flush() {
   return did_something;
 }
 
-grpc_millis ExecCtx::Now() {
+Timestamp ExecCtx::Now() {
   if (!now_is_valid_) {
-    now_ = timespec_to_millis_round_down(gpr_now(GPR_CLOCK_MONOTONIC));
+    now_ = Timestamp::FromTimespecRoundDown(gpr_now(GPR_CLOCK_MONOTONIC));
     now_is_valid_ = true;
   }
   return now_;
@@ -195,7 +118,12 @@ void ExecCtx::Run(const DebugLocation& location, grpc_closure* closure,
   closure->run = false;
   GPR_ASSERT(closure->cb != nullptr);
 #endif
-  exec_ctx_sched(closure, error);
+#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
+  closure->error_data.error = internal::StatusAllocHeapPtr(error);
+#else
+  closure->error_data.error = reinterpret_cast<intptr_t>(error);
+#endif
+  exec_ctx_sched(closure);
 }
 
 void ExecCtx::RunList(const DebugLocation& location, grpc_closure_list* list) {
@@ -218,7 +146,7 @@ void ExecCtx::RunList(const DebugLocation& location, grpc_closure_list* list) {
     c->run = false;
     GPR_ASSERT(c->cb != nullptr);
 #endif
-    exec_ctx_sched(c, c->error_data.error);
+    exec_ctx_sched(c);
     c = next;
   }
   list->head = list->tail = nullptr;

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

@@ -23,6 +23,7 @@
 
 #include <limits>
 
+#include <grpc/impl/codegen/gpr_types.h>
 #include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/atm.h>
 #include <grpc/support/cpu.h>
@@ -32,13 +33,9 @@
 #include "src/core/lib/gpr/tls.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/fork.h"
+#include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/closure.h"
 
-typedef int64_t grpc_millis;
-
-#define GRPC_MILLIS_INF_FUTURE INT64_MAX
-#define GRPC_MILLIS_INF_PAST INT64_MIN
-
 /** A combiner represents a list of work to be executed later.
     Forward declared here to avoid a circular dependency with combiner.h. */
 typedef struct grpc_combiner grpc_combiner;
@@ -57,12 +54,6 @@ typedef struct grpc_combiner grpc_combiner;
    should not be counted by fork handlers */
 #define GRPC_APP_CALLBACK_EXEC_CTX_FLAG_IS_INTERNAL_THREAD 1
 
-gpr_timespec grpc_millis_to_timespec(grpc_millis millis, gpr_clock_type clock);
-grpc_millis grpc_timespec_to_millis_round_down(gpr_timespec ts);
-grpc_millis grpc_timespec_to_millis_round_up(gpr_timespec ts);
-grpc_millis grpc_cycle_counter_to_millis_round_down(gpr_cycle_counter cycles);
-grpc_millis grpc_cycle_counter_to_millis_round_up(gpr_cycle_counter cycles);
-
 namespace grpc_core {
 class Combiner;
 /** Execution context.
@@ -189,7 +180,7 @@ class ExecCtx {
    *  otherwise refreshes the stored time, sets it valid and returns the new
    *  value.
    */
-  grpc_millis Now();
+  Timestamp Now();
 
   /** Invalidates the stored time value. A new time value will be set on calling
    *  Now().
@@ -198,31 +189,21 @@ class ExecCtx {
 
   /** To be used only by shutdown code in iomgr */
   void SetNowIomgrShutdown() {
-    now_ = GRPC_MILLIS_INF_FUTURE;
+    now_ = Timestamp::InfFuture();
     now_is_valid_ = true;
   }
 
   /** To be used only for testing.
    *  Sets the now value.
    */
-  void TestOnlySetNow(grpc_millis new_val) {
+  void TestOnlySetNow(Timestamp new_val) {
     now_ = new_val;
     now_is_valid_ = true;
   }
 
-  static void TestOnlyGlobalInit(gpr_timespec new_val);
-
-  /** Global initialization for ExecCtx. Called by iomgr. */
-  static void GlobalInit(void);
-
-  /** Global shutdown for ExecCtx. Called by iomgr. */
-  static void GlobalShutdown(void) {}
-
   /** Gets pointer to current exec_ctx. */
   static ExecCtx* Get() { return exec_ctx_; }
 
-  static void Set(ExecCtx* exec_ctx) { exec_ctx_ = exec_ctx; }
-
   static void Run(const DebugLocation& location, grpc_closure* closure,
                   grpc_error_handle error);
 
@@ -237,6 +218,7 @@ class ExecCtx {
 
  private:
   /** Set exec_ctx_ to exec_ctx. */
+  static void Set(ExecCtx* exec_ctx) { exec_ctx_ = exec_ctx; }
 
   grpc_closure_list closure_list_ = GRPC_CLOSURE_LIST_INIT;
   CombinerData combiner_data_ = {nullptr, nullptr};
@@ -245,7 +227,7 @@ class ExecCtx {
   unsigned starting_cpu_ = std::numeric_limits<unsigned>::max();
 
   bool now_is_valid_ = false;
-  grpc_millis now_ = 0;
+  Timestamp now_;
 
   static GPR_THREAD_LOCAL(ExecCtx*) exec_ctx_;
   ExecCtx* last_exec_ctx_ = Get();
@@ -370,6 +352,7 @@ class ApplicationCallbackExecCtx {
   grpc_completion_queue_functor* tail_{nullptr};
   static GPR_THREAD_LOCAL(ApplicationCallbackExecCtx*) callback_exec_ctx_;
 };
+
 }  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_IOMGR_EXEC_CTX_H */

data/src/core/lib/iomgr/executor.cc

@@ -114,7 +114,6 @@ size_t Executor::RunClosures(const char* executor_name,
   grpc_closure* c = list.head;
   while (c != nullptr) {
     grpc_closure* next = c->next_data.next;
-    grpc_error_handle error = c->error_data.error;
 #ifndef NDEBUG
     EXECUTOR_TRACE("(%s) run %p [created by %s:%d]", executor_name, c,
                    c->file_created, c->line_created);
@@ -122,8 +121,18 @@ size_t Executor::RunClosures(const char* executor_name,
 #else
     EXECUTOR_TRACE("(%s) run %p", executor_name, c);
 #endif
+#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
+    grpc_error_handle error =
+        internal::StatusMoveFromHeapPtr(c->error_data.error);
+    c->error_data.error = 0;
+    c->cb(c->cb_arg, std::move(error));
+#else
+    grpc_error_handle error =
+        reinterpret_cast<grpc_error_handle>(c->error_data.error);
+    c->error_data.error = 0;
     c->cb(c->cb_arg, error);
     GRPC_ERROR_UNREF(error);
+#endif
     c = next;
     n++;
     ExecCtx::Get()->Flush();

data/src/core/lib/iomgr/fork_posix.cc

@@ -70,6 +70,7 @@ void grpc_prefork() {
     gpr_log(GPR_INFO,
             "Fork support is only compatible with the epoll1 and poll polling "
             "strategies");
+    return;
   }
   if (!grpc_core::Fork::BlockExecCtx()) {
     gpr_log(GPR_INFO,

data/src/core/lib/iomgr/internal_errqueue.cc

@@ -1,20 +1,16 @@
-/*
- *
- * Copyright 2018 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+// Copyright 2018 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 #include <grpc/support/port_platform.h>
 
@@ -32,37 +28,32 @@
 #include <sys/utsname.h>
 
 namespace grpc_core {
-static bool errqueue_supported = false;
 
-bool kernel_supports_errqueue() { return errqueue_supported; }
-
-void grpc_errqueue_init() {
-/* Both-compile time and run-time linux kernel versions should be at least 4.0.0
- */
+bool KernelSupportsErrqueue() {
+  static const bool errqueue_supported = []() {
 #ifdef GRPC_LINUX_ERRQUEUE
-  struct utsname buffer;
-  if (uname(&buffer) != 0) {
-    gpr_log(GPR_ERROR, "uname: %s", strerror(errno));
-    return;
-  }
-  char* release = buffer.release;
-  if (release == nullptr) {
-    return;
-  }
-
-  if (strtol(release, nullptr, 10) >= 4) {
-    errqueue_supported = true;
-  } else {
-    gpr_log(GPR_DEBUG, "ERRQUEUE support not enabled");
-  }
-#endif /* GRPC_LINUX_ERRQUEUE */
+    // Both-compile time and run-time linux kernel versions should be at
+    // least 4.0.0
+    struct utsname buffer;
+    if (uname(&buffer) != 0) {
+      gpr_log(GPR_ERROR, "uname: %s", strerror(errno));
+      return false;
+    }
+    char* release = buffer.release;
+    if (release == nullptr) {
+      return false;
+    }
+
+    if (strtol(release, nullptr, 10) >= 4) {
+      return true;
+    } else {
+      gpr_log(GPR_DEBUG, "ERRQUEUE support not enabled");
+    }
+#endif  // GRPC_LINUX_ERRQUEUE
+    return false;
+  }();
+  return errqueue_supported;
 }
-} /* namespace grpc_core */
-
-#else
-
-namespace grpc_core {
-void grpc_errqueue_init() {}
-} /* namespace grpc_core */
+}  // namespace grpc_core
 
-#endif /* GRPC_POSIX_SOCKET_TCP */
+#endif  // GRPC_POSIX_SOCKET_TCP