grpc 1.50.0.pre1 → 1.51.0

data/src/core/lib/event_engine/posix_engine/ev_poll_posix.h

@@ -0,0 +1,97 @@
+// Copyright 2022 The 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_EVENT_ENGINE_POSIX_ENGINE_EV_POLL_POSIX_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EV_POLL_POSIX_H
+
+#include <grpc/support/port_platform.h>
+
+#include <atomic>
+#include <memory>
+#include <string>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/functional/function_ref.h"
+#include "absl/strings/string_view.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/event_engine/poller.h"
+#include "src/core/lib/event_engine/posix_engine/event_poller.h"
+#include "src/core/lib/event_engine/posix_engine/wakeup_fd_posix.h"
+#include "src/core/lib/gprpp/sync.h"
+
+namespace grpc_event_engine {
+namespace posix_engine {
+
+class PollEventHandle;
+
+// Definition of poll based poller.
+class PollPoller : public PosixEventPoller {
+ public:
+  explicit PollPoller(Scheduler* scheduler);
+  PollPoller(Scheduler* scheduler, bool use_phony_poll);
+  EventHandle* CreateHandle(int fd, absl::string_view name,
+                            bool track_err) override;
+  Poller::WorkResult Work(
+      grpc_event_engine::experimental::EventEngine::Duration timeout,
+      absl::FunctionRef<void()> schedule_poll_again) override;
+  std::string Name() override { return "poll"; }
+  void Kick() override;
+  Scheduler* GetScheduler() { return scheduler_; }
+  void Shutdown() override;
+  bool CanTrackErrors() const override { return false; }
+  ~PollPoller() override;
+
+ private:
+  void Ref() { ref_count_.fetch_add(1, std::memory_order_relaxed); }
+  void Unref() {
+    if (ref_count_.fetch_sub(1, std::memory_order_acq_rel) == 1) {
+      delete this;
+    }
+  }
+  void KickExternal(bool ext);
+  void PollerHandlesListAddHandle(PollEventHandle* handle)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+  void PollerHandlesListRemoveHandle(PollEventHandle* handle)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+  friend class PollEventHandle;
+  class HandlesList {
+   public:
+    explicit HandlesList(PollEventHandle* handle) : handle(handle) {}
+    PollEventHandle* handle;
+    PollEventHandle* next = nullptr;
+    PollEventHandle* prev = nullptr;
+  };
+  grpc_core::Mutex mu_;
+  Scheduler* scheduler_;
+  std::atomic<int> ref_count_{1};
+  bool use_phony_poll_;
+  bool was_kicked_ ABSL_GUARDED_BY(mu_);
+  bool was_kicked_ext_ ABSL_GUARDED_BY(mu_);
+  int num_poll_handles_ ABSL_GUARDED_BY(mu_);
+  PollEventHandle* poll_handles_list_head_ ABSL_GUARDED_BY(mu_) = nullptr;
+  std::unique_ptr<WakeupFd> wakeup_fd_;
+};
+
+// Return an instance of a poll based poller tied to the specified scheduler.
+// It use_phony_poll is true, it implies that the poller is declared
+// non-polling and any attempt to schedule a blocking poll will result in a
+// crash failure.
+PollPoller* MakePollPoller(Scheduler* scheduler, bool use_phony_poll);
+
+}  // namespace posix_engine
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EV_POLL_POSIX_H

data/src/core/lib/event_engine/posix_engine/event_poller.h

@@ -0,0 +1,111 @@
+// Copyright 2022 The 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_EVENT_ENGINE_POSIX_ENGINE_EVENT_POLLER_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EVENT_POLLER_H
+#include <grpc/support/port_platform.h>
+
+#include <string>
+
+#include "absl/functional/any_invocable.h"
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/event_engine/poller.h"
+#include "src/core/lib/event_engine/posix_engine/posix_engine_closure.h"
+
+namespace grpc_event_engine {
+namespace posix_engine {
+
+class Scheduler {
+ public:
+  virtual void Run(experimental::EventEngine::Closure* closure) = 0;
+  virtual void Run(absl::AnyInvocable<void()>) = 0;
+  virtual ~Scheduler() = default;
+};
+
+class PosixEventPoller;
+
+class EventHandle {
+ public:
+  virtual int WrappedFd() = 0;
+  // Delete the handle and optionally close the underlying file descriptor if
+  // release_fd != nullptr. The on_done closure is scheduled to be invoked
+  // after the operation is complete. After this operation, NotifyXXX and SetXXX
+  // operations cannot be performed on the handle. In general, this method
+  // should only be called after ShutdownHandle and after all existing NotifyXXX
+  // closures have run and there is no waiting NotifyXXX closure.
+  virtual void OrphanHandle(PosixEngineClosure* on_done, int* release_fd,
+                            absl::string_view reason) = 0;
+  // Shutdown a handle. If there is an attempt to call NotifyXXX operations
+  // after Shutdown handle, those closures will be run immediately with the
+  // absl::Status provided here being passed to the callbacks enclosed within
+  // the PosixEngineClosure object.
+  virtual void ShutdownHandle(absl::Status why) = 0;
+  // Schedule on_read to be invoked when the underlying file descriptor
+  // becomes readable. When the on_read closure is run, it may check
+  // if the handle is shutdown using the IsHandleShutdown method and take
+  // appropriate actions (for instance it should not try to invoke another
+  // recursive NotifyOnRead if the handle is shutdown).
+  virtual void NotifyOnRead(PosixEngineClosure* on_read) = 0;
+  // Schedule on_write to be invoked when the underlying file descriptor
+  // becomes writable. When the on_write closure is run, it may check
+  // if the handle is shutdown using the IsHandleShutdown method and take
+  // appropriate actions (for instance it should not try to invoke another
+  // recursive NotifyOnWrite if the handle is shutdown).
+  virtual void NotifyOnWrite(PosixEngineClosure* on_write) = 0;
+  // Schedule on_error to be invoked when the underlying file descriptor
+  // encounters errors. When the on_error closure is run, it may check
+  // if the handle is shutdown using the IsHandleShutdown method and take
+  // appropriate actions (for instance it should not try to invoke another
+  // recursive NotifyOnError if the handle is shutdown).
+  virtual void NotifyOnError(PosixEngineClosure* on_error) = 0;
+  // Force set a readable event on the underlying file descriptor.
+  virtual void SetReadable() = 0;
+  // Force set a writable event on the underlying file descriptor.
+  virtual void SetWritable() = 0;
+  // Force set a error event on the underlying file descriptor.
+  virtual void SetHasError() = 0;
+  // Returns true if the handle has been shutdown.
+  virtual bool IsHandleShutdown() = 0;
+  // Returns the poller which was used to create this handle.
+  virtual PosixEventPoller* Poller() = 0;
+  virtual ~EventHandle() = default;
+};
+
+class PosixEventPoller : public grpc_event_engine::experimental::Poller {
+ public:
+  // Return an opaque handle to perform actions on the provided file descriptor.
+  virtual EventHandle* CreateHandle(int fd, absl::string_view name,
+                                    bool track_err) = 0;
+  virtual bool CanTrackErrors() const = 0;
+  virtual std::string Name() = 0;
+  // Shuts down and deletes the poller. It is legal to call this function
+  // only when no other poller method is in progress. For instance, it is
+  // not safe to call this method, while a thread is blocked on Work(...).
+  // A graceful way to terminate the poller could be to:
+  // 1. First orphan all created handles.
+  // 2. Send a Kick() to the thread executing Work(...) and wait for the
+  //    thread to return.
+  // 3. Call Shutdown() on the poller.
+  virtual void Shutdown() = 0;
+  ~PosixEventPoller() override = default;
+};
+
+}  // namespace posix_engine
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EVENT_POLLER_H

data/src/core/lib/event_engine/posix_engine/event_poller_posix_default.cc

@@ -0,0 +1,74 @@
+// Copyright 2022 The 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 "absl/strings/str_split.h"
+#include "absl/strings/string_view.h"
+
+#include "src/core/lib/event_engine/posix_engine/ev_epoll1_linux.h"
+#include "src/core/lib/event_engine/posix_engine/ev_poll_posix.h"
+#include "src/core/lib/event_engine/posix_engine/event_poller.h"
+#include "src/core/lib/gprpp/global_config.h"
+#include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/iomgr/port.h"
+
+#ifdef GRPC_POSIX_SOCKET_TCP
+GPR_GLOBAL_CONFIG_DECLARE_STRING(grpc_poll_strategy);
+#endif
+
+namespace grpc_event_engine {
+namespace posix_engine {
+
+#ifdef GRPC_POSIX_SOCKET_TCP
+namespace {
+
+bool PollStrategyMatches(absl::string_view strategy, absl::string_view want) {
+  return strategy == "all" || strategy == want;
+}
+
+}  // namespace
+
+PosixEventPoller* MakeDefaultPoller(Scheduler* scheduler) {
+  static const char* poll_strategy =
+      GPR_GLOBAL_CONFIG_GET(grpc_poll_strategy).release();
+  PosixEventPoller* poller = nullptr;
+  auto strings = absl::StrSplit(poll_strategy, ',');
+  for (auto it = strings.begin(); it != strings.end() && poller == nullptr;
+       it++) {
+    if (PollStrategyMatches(*it, "epoll1")) {
+      poller = MakeEpoll1Poller(scheduler);
+    }
+    if (poller == nullptr && PollStrategyMatches(*it, "poll")) {
+      // If epoll1 fails and if poll strategy matches "poll", use Poll poller
+      poller = MakePollPoller(scheduler, /*use_phony_poll=*/false);
+    } else if (poller == nullptr && PollStrategyMatches(*it, "none")) {
+      // If epoll1 fails and if poll strategy matches "none", use phony poll
+      // poller.
+      poller = MakePollPoller(scheduler, /*use_phony_poll=*/true);
+    }
+  }
+  return poller;
+}
+
+#else  // GRPC_POSIX_SOCKET_TCP
+
+PosixEventPoller* MakeDefaultPoller(Scheduler* /*scheduler*/) {
+  return nullptr;
+}
+
+#endif  // GRPC_POSIX_SOCKET_TCP
+
+}  // namespace posix_engine
+}  // namespace grpc_event_engine

data/src/core/lib/event_engine/{executor/threaded_executor.cc → posix_engine/event_poller_posix_default.h}

@@ -1,4 +1,4 @@
-// Copyright 2022 gRPC authors.
+// Copyright 2022 The gRPC Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -12,25 +12,22 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/event_engine/executor/threaded_executor.h"
+#ifndef GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EVENT_POLLER_POSIX_DEFAULT_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EVENT_POLLER_POSIX_DEFAULT_H
 
-#include <utility>
+#include <grpc/support/port_platform.h>
 
 namespace grpc_event_engine {
-namespace experimental {
+namespace posix_engine {
 
-ThreadedExecutor::ThreadedExecutor(int reserve_threads)
-    : thread_pool_(reserve_threads){};
+class PosixEventPoller;
+class Scheduler;
 
-void ThreadedExecutor::Run(EventEngine::Closure* closure) {
-  thread_pool_.Add([closure]() { closure->Run(); });
-}
+// Return an instance of an event poller which is tied to the specified
+// scheduler.
+PosixEventPoller* MakeDefaultPoller(Scheduler* scheduler);
 
-void ThreadedExecutor::Run(absl::AnyInvocable<void()> closure) {
-  thread_pool_.Add(std::move(closure));
-}
-
-}  // namespace experimental
+}  // namespace posix_engine
 }  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EVENT_POLLER_POSIX_DEFAULT_H

data/src/core/lib/event_engine/posix_engine/internal_errqueue.cc

@@ -0,0 +1,77 @@
+// Copyright 2022 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/event_engine/posix_engine/internal_errqueue.h"
+
+#include <string>
+
+#include <grpc/support/log.h>
+
+#include "src/core/lib/iomgr/port.h"
+
+#ifdef GRPC_POSIX_SOCKET_TCP
+
+#include <errno.h>
+#include <netinet/in.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/utsname.h>
+
+#include <cstddef>
+
+#include "src/core/lib/gprpp/strerror.h"
+
+namespace grpc_event_engine {
+namespace posix_engine {
+
+#ifdef GRPC_LINUX_ERRQUEUE
+int GetSocketTcpInfo(struct tcp_info* info, int fd) {
+  memset(info, 0, sizeof(*info));
+  info->length = offsetof(tcp_info, length);
+  return getsockopt(fd, IPPROTO_TCP, TCP_INFO, info, &(info->length));
+}
+#endif
+
+bool KernelSupportsErrqueue() {
+  static const bool errqueue_supported = []() {
+#ifdef 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", grpc_core::StrError(errno).c_str());
+      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 posix_engine
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_POSIX_SOCKET_TCP

data/src/core/lib/event_engine/posix_engine/internal_errqueue.h

@@ -0,0 +1,179 @@
+// Copyright 2022 The 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_EVENT_ENGINE_POSIX_ENGINE_INTERNAL_ERRQUEUE_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_INTERNAL_ERRQUEUE_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stdint.h>
+
+#include "src/core/lib/iomgr/port.h"
+
+#ifdef GRPC_POSIX_SOCKET_TCP
+
+#include <time.h>
+
+#ifdef GRPC_LINUX_ERRQUEUE
+#include <linux/errqueue.h>  // IWYU pragma: keep
+#include <sys/socket.h>
+#endif /* GRPC_LINUX_ERRQUEUE */
+
+namespace grpc_event_engine {
+namespace posix_engine {
+
+#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
+
+int GetSocketTcpInfo(tcp_info* info, int fd);
+
+#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 KernelSupportsErrqueue();
+
+}  // namespace posix_engine
+}  // namespace grpc_event_engine
+
+#endif /* GRPC_POSIX_SOCKET_TCP */
+
+#endif /* GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_INTERNAL_ERRQUEUE_H */