grpc 1.18.0 → 1.22.0

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

@@ -25,7 +25,9 @@
 #include "src/core/lib/gprpp/thd.h"
 #include "src/core/lib/iomgr/closure.h"
 
-typedef struct {
+namespace grpc_core {
+
+struct ThreadState {
   gpr_mu mu;
   size_t id;         // For debugging purposes
   const char* name;  // Thread state name
@@ -35,24 +37,32 @@ typedef struct {
   bool shutdown;
   bool queued_long_job;
   grpc_core::Thread thd;
-} ThreadState;
+};
 
-typedef enum {
-  GRPC_EXECUTOR_SHORT = 0,
-  GRPC_EXECUTOR_LONG,
-  GRPC_NUM_EXECUTOR_JOB_TYPES  // Add new values above this
-} GrpcExecutorJobType;
+enum class ExecutorType {
+  DEFAULT = 0,
+  RESOLVER,
+
+  NUM_EXECUTORS  // Add new values above this
+};
 
-class GrpcExecutor {
+enum class ExecutorJobType {
+  SHORT = 0,
+  LONG,
+  NUM_JOB_TYPES  // Add new values above this
+};
+
+class Executor {
  public:
-  GrpcExecutor(const char* executor_name);
+  Executor(const char* executor_name);
 
   void Init();
 
   /** Is the executor multi-threaded? */
   bool IsThreaded() const;
 
-  /* Enable/disable threading - must be called after Init and Shutdown() */
+  /* Enable/disable threading - must be called after Init and Shutdown(). Never
+   * call SetThreading(false) in the middle of an application */
   void SetThreading(bool threading);
 
   /** Shutdown the executor, running all pending work as part of the call */
@@ -62,55 +72,51 @@ class GrpcExecutor {
    * a short job (i.e expected to not block and complete quickly) */
   void Enqueue(grpc_closure* closure, grpc_error* error, bool is_short);
 
- private:
-  static size_t RunClosures(const char* executor_name, grpc_closure_list list);
-  static void ThreadMain(void* arg);
+  // TODO(sreek): Currently we have two executors (available globally): The
+  // default executor and the resolver executor.
+  //
+  // Some of the functions below operate on the DEFAULT executor only while some
+  // operate of ALL the executors. This is a bit confusing and should be cleaned
+  // up in future (where we make all the following functions take ExecutorType
+  // and/or JobType)
 
-  const char* name_;
-  ThreadState* thd_state_;
-  size_t max_threads_;
-  gpr_atm num_threads_;
-  gpr_spinlock adding_thread_lock_;
-};
-
-// == Global executor functions ==
+  // Initialize ALL the executors
+  static void InitAll();
 
-typedef enum {
-  GRPC_DEFAULT_EXECUTOR = 0,
-  GRPC_RESOLVER_EXECUTOR,
+  // Shutdown ALL the executors
+  static void ShutdownAll();
 
-  GRPC_NUM_EXECUTORS  // Add new values above this
-} GrpcExecutorType;
+  // Set the threading mode for ALL the executors
+  static void SetThreadingAll(bool enable);
 
-// TODO(sreek): Currently we have two executors (available globally): The
-// default executor and the resolver executor.
-//
-// Some of the functions below operate on the DEFAULT executor only while some
-// operate of ALL the executors. This is a bit confusing and should be cleaned
-// up in future (where we make all the following functions take executor_type
-// and/or job_type)
+  // Set the threading mode for ALL the executors
+  static void SetThreadingDefault(bool enable);
 
-// Initialize ALL the executors
-void grpc_executor_init();
+  // Get the DEFAULT executor scheduler for the given job_type
+  static grpc_closure_scheduler* Scheduler(ExecutorJobType job_type);
 
-// Shutdown ALL the executors
-void grpc_executor_shutdown();
+  // Get the executor scheduler for a given executor_type and a job_type
+  static grpc_closure_scheduler* Scheduler(ExecutorType executor_type,
+                                           ExecutorJobType job_type);
 
-// Set the threading mode for ALL the executors
-void grpc_executor_set_threading(bool enable);
+  // Return if a given executor is running in threaded mode (i.e if
+  // SetThreading(true) was called previously on that executor)
+  static bool IsThreaded(ExecutorType executor_type);
 
-// Get the DEFAULT executor scheduler for the given job_type
-grpc_closure_scheduler* grpc_executor_scheduler(GrpcExecutorJobType job_type);
+  // Return if the DEFAULT executor is threaded
+  static bool IsThreadedDefault();
 
-// Get the executor scheduler for a given executor_type and a job_type
-grpc_closure_scheduler* grpc_executor_scheduler(GrpcExecutorType executor_type,
-                                                GrpcExecutorJobType job_type);
+ private:
+  static size_t RunClosures(const char* executor_name, grpc_closure_list list);
+  static void ThreadMain(void* arg);
 
-// Return if a given executor is running in threaded mode (i.e if
-// grpc_executor_set_threading(true) was called previously on that executor)
-bool grpc_executor_is_threaded(GrpcExecutorType executor_type);
+  const char* name_;
+  ThreadState* thd_state_;
+  size_t max_threads_;
+  gpr_atm num_threads_;
+  gpr_spinlock adding_thread_lock_;
+};
 
-// Return if the DEFAULT executor is threaded
-bool grpc_executor_is_threaded();
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_IOMGR_EXECUTOR_H */

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

@@ -28,7 +28,6 @@
 #include <grpc/grpc.h>
 #include <grpc/support/log.h>
 
-#include "src/core/lib/gpr/env.h"
 #include "src/core/lib/gprpp/fork.h"
 #include "src/core/lib/gprpp/thd.h"
 #include "src/core/lib/iomgr/ev_posix.h"
@@ -47,11 +46,13 @@ bool registered_handlers = false;
 }  // namespace
 
 void grpc_prefork() {
-  grpc_core::ExecCtx exec_ctx;
   skipped_handler = true;
+  // This  may be called after core shuts down, so verify initialized before
+  // instantiating an ExecCtx.
   if (!grpc_is_initialized()) {
     return;
   }
+  grpc_core::ExecCtx exec_ctx;
   if (!grpc_core::Fork::Enabled()) {
     gpr_log(GPR_ERROR,
             "Fork support not enabled; try running with the "
@@ -71,7 +72,7 @@ void grpc_prefork() {
     return;
   }
   grpc_timer_manager_set_threading(false);
-  grpc_executor_set_threading(false);
+  grpc_core::Executor::SetThreadingAll(false);
   grpc_core::ExecCtx::Get()->Flush();
   grpc_core::Fork::AwaitThreads();
   skipped_handler = false;
@@ -82,7 +83,7 @@ void grpc_postfork_parent() {
     grpc_core::Fork::AllowExecCtx();
     grpc_core::ExecCtx exec_ctx;
     grpc_timer_manager_set_threading(true);
-    grpc_executor_set_threading(true);
+    grpc_core::Executor::SetThreadingAll(true);
   }
 }
 
@@ -96,7 +97,7 @@ void grpc_postfork_child() {
       reset_polling_engine();
     }
     grpc_timer_manager_set_threading(true);
-    grpc_executor_set_threading(true);
+    grpc_core::Executor::SetThreadingAll(true);
   }
 }
 

data/src/core/lib/{gprpp/atomic_with_std.h → iomgr/grpc_if_nametoindex.h}

@@ -1,6 +1,6 @@
 /*
  *
- * Copyright 2017 gRPC authors.
+ * Copyright 2015 gRPC authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,20 +16,15 @@
  *
  */
 
-#ifndef GRPC_CORE_LIB_GPRPP_ATOMIC_WITH_STD_H
-#define GRPC_CORE_LIB_GPRPP_ATOMIC_WITH_STD_H
+#ifndef GRPC_CORE_LIB_IOMGR_GRPC_IF_NAMETOINDEX_H
+#define GRPC_CORE_LIB_IOMGR_GRPC_IF_NAMETOINDEX_H
 
 #include <grpc/support/port_platform.h>
 
-#include <atomic>
+#include <stddef.h>
 
-namespace grpc_core {
+/* Returns the interface index corresponding to the interface "name" provided.
+ * Returns non-zero upon success, and zero upon failure. */
+uint32_t grpc_if_nametoindex(char* name);
 
-template <class T>
-using atomic = std::atomic<T>;
-
-typedef std::memory_order memory_order;
-
-}  // namespace grpc_core
-
-#endif /* GRPC_CORE_LIB_GPRPP_ATOMIC_WITH_STD_H */
+#endif /* GRPC_CORE_LIB_IOMGR_GRPC_IF_NAMETOINDEX_H */

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

@@ -0,0 +1,42 @@
+/*
+ *
+ * Copyright 2016 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>
+
+#include "src/core/lib/iomgr/port.h"
+
+#if GRPC_IF_NAMETOINDEX == 1 && defined(GRPC_POSIX_SOCKET_IF_NAMETOINDEX)
+
+#include "src/core/lib/iomgr/grpc_if_nametoindex.h"
+
+#include <errno.h>
+#include <net/if.h>
+
+#include <grpc/support/log.h>
+
+uint32_t grpc_if_nametoindex(char* name) {
+  uint32_t out = if_nametoindex(name);
+  if (out == 0) {
+    gpr_log(GPR_DEBUG, "if_nametoindex failed for name %s. errno %d", name,
+            errno);
+  }
+  return out;
+}
+
+#endif /* GRPC_IF_NAMETOINDEX == 1 && \
+          defined(GRPC_POSIX_SOCKET_IF_NAMETOINDEX) */

data/src/core/lib/iomgr/{network_status_tracker.h → grpc_if_nametoindex_unsupported.cc}

@@ -16,17 +16,23 @@
  *
  */
 
-#ifndef GRPC_CORE_LIB_IOMGR_NETWORK_STATUS_TRACKER_H
-#define GRPC_CORE_LIB_IOMGR_NETWORK_STATUS_TRACKER_H
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/iomgr/endpoint.h"
+#include "src/core/lib/iomgr/port.h"
 
-void grpc_network_status_init(void);
-void grpc_network_status_shutdown(void);
+#if GRPC_IF_NAMETOINDEX == 0 || !defined(GRPC_POSIX_SOCKET_IF_NAMETOINDEX)
 
-void grpc_network_status_register_endpoint(grpc_endpoint* ep);
-void grpc_network_status_unregister_endpoint(grpc_endpoint* ep);
-void grpc_network_status_shutdown_all_endpoints();
+#include "src/core/lib/iomgr/grpc_if_nametoindex.h"
 
-#endif /* GRPC_CORE_LIB_IOMGR_NETWORK_STATUS_TRACKER_H */
+#include <grpc/support/log.h>
+
+uint32_t grpc_if_nametoindex(char* name) {
+  gpr_log(GPR_DEBUG,
+          "Not attempting to convert interface name %s to index for current "
+          "platform.",
+          name);
+  return 0;
+}
+
+#endif /* GRPC_IF_NAMETOINDEX == 0 || \
+          !defined(GRPC_POSIX_SOCKET_IF_NAMETOINDEX) */

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

@@ -36,10 +36,9 @@ 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 atleast 4.0.0
+/* Both-compile time and run-time linux kernel versions should be at least 4.0.0
  */
-#ifdef LINUX_VERSION_CODE
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 0, 0)
+#ifdef GRPC_LINUX_ERRQUEUE
   struct utsname buffer;
   if (uname(&buffer) != 0) {
     gpr_log(GPR_ERROR, "uname: %s", strerror(errno));
@@ -55,8 +54,7 @@ void grpc_errqueue_init() {
   } else {
     gpr_log(GPR_DEBUG, "ERRQUEUE support not enabled");
   }
-#endif /* LINUX_VERSION_CODE <= KERNEL_VERSION(4, 0, 0) */
-#endif /* LINUX_VERSION_CODE */
+#endif /* GRPC_LINUX_ERRQUEUE */
 }
 } /* namespace grpc_core */
 

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

@@ -37,6 +37,7 @@
 #ifdef GRPC_LINUX_ERRQUEUE
 #include <linux/errqueue.h>
 #include <linux/net_tstamp.h>
+#include <linux/netlink.h>
 #include <sys/socket.h>
 #endif /* GRPC_LINUX_ERRQUEUE */
 
@@ -56,6 +57,12 @@ constexpr int SCM_TSTAMP_SND = 0;
 constexpr int SCM_TSTAMP_SCHED = 1;
 /* The timestamp type for when data acknowledged by peer. */
 constexpr int SCM_TSTAMP_ACK = 2;
+
+/* Control message type containing OPT_STATS */
+#ifndef SCM_TIMESTAMPING_OPT_STATS
+#define SCM_TIMESTAMPING_OPT_STATS 54
+#endif
+
 /* Redefine required constants from <linux/net_tstamp.h> */
 constexpr uint32_t SOF_TIMESTAMPING_TX_SOFTWARE = 1u << 1;
 constexpr uint32_t SOF_TIMESTAMPING_SOFTWARE = 1u << 4;
@@ -63,13 +70,108 @@ constexpr uint32_t SOF_TIMESTAMPING_OPT_ID = 1u << 7;
 constexpr uint32_t SOF_TIMESTAMPING_TX_SCHED = 1u << 8;
 constexpr uint32_t SOF_TIMESTAMPING_TX_ACK = 1u << 9;
 constexpr uint32_t SOF_TIMESTAMPING_OPT_TSONLY = 1u << 11;
+constexpr uint32_t SOF_TIMESTAMPING_OPT_STATS = 1u << 12;
 
-constexpr uint32_t kTimestampingSocketOptions = SOF_TIMESTAMPING_SOFTWARE |
-                                                SOF_TIMESTAMPING_OPT_ID |
-                                                SOF_TIMESTAMPING_OPT_TSONLY;
+constexpr uint32_t kTimestampingSocketOptions =
+    SOF_TIMESTAMPING_SOFTWARE | SOF_TIMESTAMPING_OPT_ID |
+    SOF_TIMESTAMPING_OPT_TSONLY | SOF_TIMESTAMPING_OPT_STATS;
 constexpr uint32_t kTimestampingRecordingOptions =
     SOF_TIMESTAMPING_TX_SCHED | SOF_TIMESTAMPING_TX_SOFTWARE |
     SOF_TIMESTAMPING_TX_ACK;
+
+/* Netlink attribute types used for TCP opt stats. */
+enum TCPOptStats {
+  TCP_NLA_PAD,
+  TCP_NLA_BUSY,           /* Time (usec) busy sending data. */
+  TCP_NLA_RWND_LIMITED,   /* Time (usec) limited by receive window. */
+  TCP_NLA_SNDBUF_LIMITED, /* Time (usec) limited by send buffer. */
+  TCP_NLA_DATA_SEGS_OUT,  /* Data pkts sent including retransmission. */
+  TCP_NLA_TOTAL_RETRANS,  /* Data pkts retransmitted. */
+  TCP_NLA_PACING_RATE,    /* Pacing rate in Bps. */
+  TCP_NLA_DELIVERY_RATE,  /* Delivery rate in Bps. */
+  TCP_NLA_SND_CWND,       /* Sending congestion window. */
+  TCP_NLA_REORDERING,     /* Reordering metric. */
+  TCP_NLA_MIN_RTT,        /* minimum RTT. */
+  TCP_NLA_RECUR_RETRANS,  /* Recurring retransmits for the current pkt. */
+  TCP_NLA_DELIVERY_RATE_APP_LMT, /* Delivery rate application limited? */
+  TCP_NLA_SNDQ_SIZE,             /* Data (bytes) pending in send queue */
+  TCP_NLA_CA_STATE,              /* ca_state of socket */
+  TCP_NLA_SND_SSTHRESH,          /* Slow start size threshold */
+  TCP_NLA_DELIVERED,             /* Data pkts delivered incl. out-of-order */
+  TCP_NLA_DELIVERED_CE,          /* Like above but only ones w/ CE marks */
+  TCP_NLA_BYTES_SENT,            /* Data bytes sent including retransmission */
+  TCP_NLA_BYTES_RETRANS,         /* Data bytes retransmitted */
+  TCP_NLA_DSACK_DUPS,            /* DSACK blocks received */
+  TCP_NLA_REORD_SEEN,            /* reordering events seen */
+  TCP_NLA_SRTT,                  /* smoothed RTT in usecs */
+};
+
+/* tcp_info from from linux/tcp.h */
+struct tcp_info {
+  uint8_t tcpi_state;
+  uint8_t tcpi_ca_state;
+  uint8_t tcpi_retransmits;
+  uint8_t tcpi_probes;
+  uint8_t tcpi_backoff;
+  uint8_t tcpi_options;
+  uint8_t tcpi_snd_wscale : 4, tcpi_rcv_wscale : 4;
+  uint8_t tcpi_delivery_rate_app_limited : 1;
+  uint32_t tcpi_rto;
+  uint32_t tcpi_ato;
+  uint32_t tcpi_snd_mss;
+  uint32_t tcpi_rcv_mss;
+  uint32_t tcpi_unacked;
+  uint32_t tcpi_sacked;
+  uint32_t tcpi_lost;
+  uint32_t tcpi_retrans;
+  uint32_t tcpi_fackets;
+  /* Times. */
+  uint32_t tcpi_last_data_sent;
+  uint32_t tcpi_last_ack_sent; /* Not remembered, sorry. */
+  uint32_t tcpi_last_data_recv;
+  uint32_t tcpi_last_ack_recv;
+  /* Metrics. */
+  uint32_t tcpi_pmtu;
+  uint32_t tcpi_rcv_ssthresh;
+  uint32_t tcpi_rtt;
+  uint32_t tcpi_rttvar;
+  uint32_t tcpi_snd_ssthresh;
+  uint32_t tcpi_snd_cwnd;
+  uint32_t tcpi_advmss;
+  uint32_t tcpi_reordering;
+  uint32_t tcpi_rcv_rtt;
+  uint32_t tcpi_rcv_space;
+  uint32_t tcpi_total_retrans;
+  uint64_t tcpi_pacing_rate;
+  uint64_t tcpi_max_pacing_rate;
+  uint64_t tcpi_bytes_acked;    /* RFC4898 tcpEStatsAppHCThruOctetsAcked */
+  uint64_t tcpi_bytes_received; /* RFC4898 tcpEStatsAppHCThruOctetsReceived */
+
+  uint32_t tcpi_segs_out; /* RFC4898 tcpEStatsPerfSegsOut */
+  uint32_t tcpi_segs_in;  /* RFC4898 tcpEStatsPerfSegsIn */
+  uint32_t tcpi_notsent_bytes;
+  uint32_t tcpi_min_rtt;
+
+  uint32_t tcpi_data_segs_in;  /* RFC4898 tcpEStatsDataSegsIn */
+  uint32_t tcpi_data_segs_out; /* RFC4898 tcpEStatsDataSegsOut */
+
+  uint64_t tcpi_delivery_rate;
+  uint64_t tcpi_busy_time;      /* Time (usec) busy sending data */
+  uint64_t tcpi_rwnd_limited;   /* Time (usec) limited by receive window */
+  uint64_t tcpi_sndbuf_limited; /* Time (usec) limited by send buffer */
+
+  uint32_t tcpi_delivered;
+  uint32_t tcpi_delivered_ce;
+  uint64_t tcpi_bytes_sent;    /* RFC4898 tcpEStatsPerfHCDataOctetsOut */
+  uint64_t tcpi_bytes_retrans; /* RFC4898 tcpEStatsPerfOctetsRetrans */
+  uint32_t tcpi_dsack_dups;    /* RFC4898 tcpEStatsStackDSACKDups */
+  uint32_t tcpi_reord_seen;    /* reordering events seen */
+  socklen_t length;            /* Length of struct returned by kernel */
+};
+
+#ifndef TCP_INFO
+#define TCP_INFO 11
+#endif
 #endif /* GRPC_LINUX_ERRQUEUE */
 
 /* Returns true if kernel is capable of supporting errqueue and timestamping.

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

@@ -29,23 +29,27 @@
 #include <grpc/support/string_util.h>
 #include <grpc/support/sync.h>
 
-#include "src/core/lib/gpr/env.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/global_config.h"
 #include "src/core/lib/gprpp/thd.h"
 #include "src/core/lib/iomgr/buffer_list.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/internal_errqueue.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
-#include "src/core/lib/iomgr/network_status_tracker.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/iomgr/timer_manager.h"
 
+GPR_GLOBAL_CONFIG_DEFINE_BOOL(grpc_abort_on_leaks, false,
+                              "A debugging aid to cause a call to abort() when "
+                              "gRPC objects are leaked past grpc_shutdown()");
+
 static gpr_mu g_mu;
 static gpr_cv g_rcv;
 static int g_shutdown;
 static grpc_iomgr_object g_root_object;
+static bool g_grpc_abort_on_leaks;
 
 void grpc_iomgr_init() {
   grpc_core::ExecCtx exec_ctx;
@@ -53,13 +57,13 @@ void grpc_iomgr_init() {
   g_shutdown = 0;
   gpr_mu_init(&g_mu);
   gpr_cv_init(&g_rcv);
-  grpc_executor_init();
-  grpc_timer_list_init();
+  grpc_core::Executor::InitAll();
   g_root_object.next = g_root_object.prev = &g_root_object;
   g_root_object.name = (char*)"root";
-  grpc_network_status_init();
   grpc_iomgr_platform_init();
+  grpc_timer_list_init();
   grpc_core::grpc_errqueue_init();
+  g_grpc_abort_on_leaks = GPR_GLOBAL_CONFIG_GET(grpc_abort_on_leaks);
 }
 
 void grpc_iomgr_start() { grpc_timer_manager_init(); }
@@ -90,7 +94,7 @@ void grpc_iomgr_shutdown() {
   {
     grpc_timer_manager_shutdown();
     grpc_iomgr_platform_flush();
-    grpc_executor_shutdown();
+    grpc_core::Executor::ShutdownAll();
 
     gpr_mu_lock(&g_mu);
     g_shutdown = 1;
@@ -152,7 +156,6 @@ void grpc_iomgr_shutdown() {
   gpr_mu_unlock(&g_mu);
 
   grpc_iomgr_platform_shutdown();
-  grpc_network_status_shutdown();
   gpr_mu_destroy(&g_mu);
   gpr_cv_destroy(&g_rcv);
 }
@@ -161,6 +164,15 @@ void grpc_iomgr_shutdown_background_closure() {
   grpc_iomgr_platform_shutdown_background_closure();
 }
 
+bool grpc_iomgr_is_any_background_poller_thread() {
+  return grpc_iomgr_platform_is_any_background_poller_thread();
+}
+
+bool grpc_iomgr_add_closure_to_background_poller(grpc_closure* closure,
+                                                 grpc_error* error) {
+  return grpc_iomgr_platform_add_closure_to_background_poller(closure, error);
+}
+
 void grpc_iomgr_register_object(grpc_iomgr_object* obj, const char* name) {
   obj->name = gpr_strdup(name);
   gpr_mu_lock(&g_mu);
@@ -179,9 +191,4 @@ void grpc_iomgr_unregister_object(grpc_iomgr_object* obj) {
   gpr_free(obj->name);
 }
 
-bool grpc_iomgr_abort_on_leaks(void) {
-  char* env = gpr_getenv("GRPC_ABORT_ON_LEAKS");
-  bool should_we = gpr_is_true(env);
-  gpr_free(env);
-  return should_we;
-}
+bool grpc_iomgr_abort_on_leaks(void) { return g_grpc_abort_on_leaks; }

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

@@ -21,6 +21,7 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/port.h"
 
 #include <stdlib.h>
@@ -39,6 +40,20 @@ void grpc_iomgr_shutdown();
  * background poller. */
 void grpc_iomgr_shutdown_background_closure();
 
+/* Returns true if polling engine runs in the background, false otherwise.
+ * Currently only 'epollbg' runs in the background.
+ */
+bool grpc_iomgr_run_in_background();
+
+/** Returns true if the caller is a worker thread for any background poller. */
+bool grpc_iomgr_is_any_background_poller_thread();
+
+/** Returns true if the closure is registered into the background poller. Note
+ * that the closure may or may not run yet when this function returns, and the
+ * closure should not be blocking or long-running. */
+bool grpc_iomgr_add_closure_to_background_poller(grpc_closure* closure,
+                                                 grpc_error* error);
+
 /* Exposed only for testing */
 size_t grpc_iomgr_count_objects_for_testing();
 

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

@@ -34,22 +34,36 @@ gpr_thd_id g_init_thread;
 
 static void iomgr_platform_init(void) {
   grpc_core::ExecCtx exec_ctx;
-  grpc_executor_set_threading(false);
+  grpc_core::Executor::SetThreadingAll(false);
   g_init_thread = gpr_thd_currentid();
   grpc_pollset_global_init();
 }
 static void iomgr_platform_flush(void) {}
 static void iomgr_platform_shutdown(void) { grpc_pollset_global_shutdown(); }
 static void iomgr_platform_shutdown_background_closure(void) {}
+static bool iomgr_platform_is_any_background_poller_thread(void) {
+  return false;
+}
+static bool iomgr_platform_add_closure_to_background_poller(
+    grpc_closure* closure, grpc_error* error) {
+  return false;
+}
+
+bool g_custom_iomgr_enabled = false;
 
 static grpc_iomgr_platform_vtable vtable = {
-    iomgr_platform_init, iomgr_platform_flush, iomgr_platform_shutdown,
-    iomgr_platform_shutdown_background_closure};
+    iomgr_platform_init,
+    iomgr_platform_flush,
+    iomgr_platform_shutdown,
+    iomgr_platform_shutdown_background_closure,
+    iomgr_platform_is_any_background_poller_thread,
+    iomgr_platform_add_closure_to_background_poller};
 
 void grpc_custom_iomgr_init(grpc_socket_vtable* socket,
                             grpc_custom_resolver_vtable* resolver,
                             grpc_custom_timer_vtable* timer,
                             grpc_custom_poller_vtable* poller) {
+  g_custom_iomgr_enabled = true;
   grpc_custom_endpoint_init(socket);
   grpc_custom_timer_init(timer);
   grpc_custom_pollset_init(poller);

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

@@ -39,6 +39,8 @@ extern gpr_thd_id g_init_thread;
 #define GRPC_CUSTOM_IOMGR_ASSERT_SAME_THREAD()
 #endif /* GRPC_CUSTOM_IOMGR_THREAD_CHECK */
 
+extern bool g_custom_iomgr_enabled;
+
 void grpc_custom_iomgr_init(grpc_socket_vtable* socket,
                             grpc_custom_resolver_vtable* resolver,
                             grpc_custom_timer_vtable* timer,

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

@@ -45,3 +45,13 @@ void grpc_iomgr_platform_shutdown() { iomgr_platform_vtable->shutdown(); }
 void grpc_iomgr_platform_shutdown_background_closure() {
   iomgr_platform_vtable->shutdown_background_closure();
 }
+
+bool grpc_iomgr_platform_is_any_background_poller_thread() {
+  return iomgr_platform_vtable->is_any_background_poller_thread();
+}
+
+bool grpc_iomgr_platform_add_closure_to_background_poller(grpc_closure* closure,
+                                                          grpc_error* error) {
+  return iomgr_platform_vtable->add_closure_to_background_poller(closure,
+                                                                 error);
+}

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

@@ -36,6 +36,9 @@ typedef struct grpc_iomgr_platform_vtable {
   void (*flush)(void);
   void (*shutdown)(void);
   void (*shutdown_background_closure)(void);
+  bool (*is_any_background_poller_thread)(void);
+  bool (*add_closure_to_background_poller)(grpc_closure* closure,
+                                           grpc_error* error);
 } grpc_iomgr_platform_vtable;
 
 void grpc_iomgr_register_object(grpc_iomgr_object* obj, const char* name);
@@ -56,6 +59,15 @@ void grpc_iomgr_platform_shutdown(void);
 /** shut down all the closures registered in the background poller */
 void grpc_iomgr_platform_shutdown_background_closure(void);
 
+/** return true if the caller is a worker thread for any background poller */
+bool grpc_iomgr_platform_is_any_background_poller_thread(void);
+
+/** Return true if the closure is registered into the background poller. Note
+ * that the closure may or may not run yet when this function returns, and the
+ * closure should not be blocking or long-running. */
+bool grpc_iomgr_platform_add_closure_to_background_poller(grpc_closure* closure,
+                                                          grpc_error* error);
+
 bool grpc_iomgr_abort_on_leaks(void);
 
 #endif /* GRPC_CORE_LIB_IOMGR_IOMGR_INTERNAL_H */