grpc 1.15.0 → 1.30.0

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

@@ -0,0 +1,149 @@
+/*
+ *
+ * Copyright 2019 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.
+ *
+ */
+
+#ifndef GRPC_CORE_LIB_IOMGR_EXECUTOR_THREADPOOL_H
+#define GRPC_CORE_LIB_IOMGR_EXECUTOR_THREADPOOL_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/grpc.h>
+
+#include "src/core/lib/gprpp/thd.h"
+#include "src/core/lib/iomgr/executor/mpmcqueue.h"
+
+namespace grpc_core {
+
+// A base abstract base class for threadpool.
+// Threadpool is an executor that maintains a pool of threads sitting around
+// and waiting for closures. A threadpool also maintains a queue of pending
+// closures, when closures appearing in the queue, the threads in pool will
+// pull them out and execute them.
+class ThreadPoolInterface {
+ public:
+  // Waits for all pending closures to complete, then shuts down thread pool.
+  virtual ~ThreadPoolInterface() {}
+
+  // Schedules a given closure for execution later.
+  // Depending on specific subclass implementation, this routine might cause
+  // current thread to be blocked (in case of unable to schedule).
+  // Closure should contain a function pointer and arguments it will take, more
+  // details for closure struct at /grpc/include/grpc/impl/codegen/grpc_types.h
+  virtual void Add(grpc_experimental_completion_queue_functor* closure) = 0;
+
+  // Returns the current number of pending closures
+  virtual int num_pending_closures() const = 0;
+
+  // Returns the capacity of pool (number of worker threads in pool)
+  virtual int pool_capacity() const = 0;
+
+  // Thread option accessor
+  virtual const Thread::Options& thread_options() const = 0;
+
+  // Returns the thread name for threads in this ThreadPool.
+  virtual const char* thread_name() const = 0;
+};
+
+// Worker thread for threadpool. Executes closures in the queue, until getting a
+// NULL closure.
+class ThreadPoolWorker {
+ public:
+  ThreadPoolWorker(const char* thd_name, MPMCQueueInterface* queue,
+                   Thread::Options& options, int index)
+      : queue_(queue), thd_name_(thd_name), index_(index) {
+    thd_ = Thread(thd_name,
+                  [](void* th) { static_cast<ThreadPoolWorker*>(th)->Run(); },
+                  this, nullptr, options);
+  }
+
+  ~ThreadPoolWorker() {}
+
+  void Start() { thd_.Start(); }
+  void Join() { thd_.Join(); }
+
+ private:
+  // struct for tracking stats of thread
+  struct Stats {
+    gpr_timespec sleep_time;
+    Stats() { sleep_time = gpr_time_0(GPR_TIMESPAN); }
+  };
+
+  void Run();  // Pulls closures from queue and executes them
+
+  MPMCQueueInterface* queue_;  // Queue in thread pool to pull closures from
+  Thread thd_;                 // Thread wrapped in
+  Stats stats_;                // Stats to be collected in run time
+  const char* thd_name_;       // Name of thread
+  int index_;                  // Index in thread pool
+};
+
+// A fixed size thread pool implementation of abstract thread pool interface.
+// In this implementation, the number of threads in pool is fixed, but the
+// capacity of closure queue is unlimited.
+class ThreadPool : public ThreadPoolInterface {
+ public:
+  // Creates a thread pool with size of "num_threads", with default thread name
+  // "ThreadPoolWorker" and all thread options set to default. If the given size
+  // is 0 or less, there will be 1 worker thread created inside pool.
+  ThreadPool(int num_threads);
+
+  // Same as ThreadPool(int num_threads) constructor, except
+  // that it also sets "thd_name" as the name of all threads in the thread pool.
+  ThreadPool(int num_threads, const char* thd_name);
+
+  // Same as ThreadPool(const char *thd_name, int num_threads) constructor,
+  // except that is also set thread_options for threads.
+  // Notes for stack size:
+  // If the stack size field of the passed in Thread::Options is set to default
+  // value 0, default ThreadPool stack size will be used. The current default
+  // stack size of this implementation is 1952K for mobile platform and 64K for
+  // all others.
+  ThreadPool(int num_threads, const char* thd_name,
+             const Thread::Options& thread_options);
+
+  // Waits for all pending closures to complete, then shuts down thread pool.
+  ~ThreadPool() override;
+
+  // Adds given closure into pending queue immediately. Since closure queue has
+  // infinite length, this routine will not block.
+  void Add(grpc_experimental_completion_queue_functor* closure) override;
+
+  int num_pending_closures() const override;
+  int pool_capacity() const override;
+  const Thread::Options& thread_options() const override;
+  const char* thread_name() const override;
+
+ private:
+  int num_threads_ = 0;
+  const char* thd_name_ = nullptr;
+  Thread::Options thread_options_;
+  ThreadPoolWorker** threads_ = nullptr;  // Array of worker threads
+  MPMCQueueInterface* queue_ = nullptr;   // Closure queue
+
+  Atomic<bool> shut_down_{false};  // Destructor has been called if set to true
+
+  void SharedThreadPoolConstructor();
+  // For ThreadPool, default stack size for mobile platform is 1952K. for other
+  // platforms is 64K.
+  size_t DefaultStackSize();
+  // Internal Use Only for debug checking.
+  void AssertHasNotBeenShutDown();
+};
+
+}  // namespace grpc_core
+
+#endif /* GRPC_CORE_LIB_IOMGR_EXECUTOR_THREADPOOL_H */

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

@@ -22,13 +22,16 @@
 
 #ifdef GRPC_POSIX_FORK
 
+#ifdef GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK
+#include <pthread.h>
+#endif
+
 #include <string.h>
 
 #include <grpc/fork.h>
 #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,20 +50,24 @@ 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 "
             "environment variable GRPC_ENABLE_FORK_SUPPORT=1");
     return;
   }
-  if (strcmp(grpc_get_poll_strategy_name(), "epoll1") != 0 &&
-      strcmp(grpc_get_poll_strategy_name(), "poll") != 0) {
-    gpr_log(GPR_ERROR,
+  const char* poll_strategy_name = grpc_get_poll_strategy_name();
+  if (poll_strategy_name == nullptr ||
+      (strcmp(poll_strategy_name, "epoll1") != 0 &&
+       strcmp(poll_strategy_name, "poll") != 0)) {
+    gpr_log(GPR_INFO,
             "Fork support is only compatible with the epoll1 and poll polling "
             "strategies");
   }
@@ -71,7 +78,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 +89,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 +103,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/iomgr/grpc_if_nametoindex.h

@@ -0,0 +1,30 @@
+/*
+ *
+ * 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.
+ * 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.
+ *
+ */
+
+#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 <stddef.h>
+
+/* 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);
+
+#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/grpc_if_nametoindex_unsupported.cc

@@ -0,0 +1,38 @@
+/*
+ *
+ * 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 == 0 || !defined(GRPC_POSIX_SOCKET_IF_NAMETOINDEX)
+
+#include "src/core/lib/iomgr/grpc_if_nametoindex.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

@@ -0,0 +1,67 @@
+/*
+ *
+ * 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>
+
+#include "src/core/lib/iomgr/port.h"
+
+#include <grpc/impl/codegen/log.h>
+#include "src/core/lib/iomgr/internal_errqueue.h"
+
+#ifdef GRPC_POSIX_SOCKET_TCP
+
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#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
+ */
+#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 */
+}
+} /* namespace grpc_core */
+
+#else
+
+namespace grpc_core {
+void grpc_errqueue_init() {}
+} /* namespace grpc_core */
+
+#endif /* GRPC_POSIX_SOCKET_TCP */

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

@@ -0,0 +1,191 @@
+/*
+ *
+ * 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.
+ *
+ */
+
+/* This file contains constants defined in <linux/errqueue.h> and
+ * <linux/net_tstamp.h> so as to allow collecting network timestamps in the
+ * kernel. This file allows tcp_posix.cc to compile on platforms that do not
+ * have <linux/errqueue.h> and <linux/net_tstamp.h>.
+ */
+
+#ifndef GRPC_CORE_LIB_IOMGR_INTERNAL_ERRQUEUE_H
+#define GRPC_CORE_LIB_IOMGR_INTERNAL_ERRQUEUE_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/iomgr/port.h"
+
+#ifdef GRPC_POSIX_SOCKET_TCP
+
+#include <sys/types.h>
+#include <time.h>
+
+#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 */
+
+namespace grpc_core {
+
+#ifdef GRPC_LINUX_ERRQUEUE
+
+/* Redefining scm_timestamping in the same way that <linux/errqueue.h> defines
+ * it, so that code compiles on systems that don't have it. */
+struct scm_timestamping {
+  struct timespec ts[3];
+};
+/* Also redefine timestamp types */
+/* The timestamp type for when the driver passed skb to NIC, or HW. */
+constexpr int SCM_TSTAMP_SND = 0;
+/* The timestamp type for when data entered the packet scheduler. */
+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;
+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 | 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.
+ * Currently allowing only linux kernels above 4.0.0
+ */
+bool kernel_supports_errqueue();
+
+} /* namespace grpc_core */
+
+#endif /* GRPC_POSIX_SOCKET_TCP */
+
+namespace grpc_core {
+/* Initializes errqueue support */
+void grpc_errqueue_init();
+} /* namespace grpc_core */
+
+#endif /* GRPC_CORE_LIB_IOMGR_INTERNAL_ERRQUEUE_H */