grpc 1.50.0.pre1 → 1.52.0.pre2

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

@@ -0,0 +1,332 @@
+// 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 "src/core/lib/event_engine/posix_engine/traced_buffer_list.h"
+
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include <utility>
+
+#include "absl/functional/any_invocable.h"
+
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/iomgr/port.h"
+
+#ifdef GRPC_LINUX_ERRQUEUE
+#include <linux/errqueue.h>  // IWYU pragma: keep
+#include <linux/netlink.h>
+#include <sys/socket.h>  // IWYU pragma: keep
+
+namespace grpc_event_engine {
+namespace experimental {
+
+namespace {
+// Fills gpr_timespec gts based on values from timespec ts.
+void FillGprFromTimestamp(gpr_timespec* gts, const struct timespec* ts) {
+  gts->tv_sec = ts->tv_sec;
+  gts->tv_nsec = static_cast<int32_t>(ts->tv_nsec);
+  gts->clock_type = GPR_CLOCK_REALTIME;
+}
+
+void DefaultTimestampsCallback(void* /*arg*/, Timestamps* /*ts*/,
+                               absl::Status /*shudown_err*/) {
+  gpr_log(GPR_DEBUG, "Timestamps callback has not been registered");
+}
+
+// The saved callback function that will be invoked when we get all the
+// timestamps that we are going to get for a TracedBuffer.
+absl::AnyInvocable<void(void*, Timestamps*, absl::Status)>
+    g_timestamps_callback =
+        []() -> absl::AnyInvocable<void(void*, Timestamps*, absl::Status)> {
+  return DefaultTimestampsCallback;
+}();
+
+// Used to extract individual opt stats from cmsg, so as to avoid troubles with
+// unaligned reads.
+template <typename T>
+T ReadUnaligned(const void* ptr) {
+  T val;
+  memcpy(&val, ptr, sizeof(val));
+  return val;
+}
+
+// Extracts opt stats from the tcp_info struct \a info to \a metrics
+void ExtractOptStatsFromTcpInfo(ConnectionMetrics* metrics,
+                                const tcp_info* info) {
+  if (info == nullptr) {
+    return;
+  }
+  if (info->length > offsetof(tcp_info, tcpi_sndbuf_limited)) {
+    metrics->recurring_retrans = info->tcpi_retransmits;
+    metrics->is_delivery_rate_app_limited =
+        info->tcpi_delivery_rate_app_limited;
+    metrics->congestion_window = info->tcpi_snd_cwnd;
+    metrics->reordering = info->tcpi_reordering;
+    metrics->packet_retx = info->tcpi_total_retrans;
+    metrics->pacing_rate = info->tcpi_pacing_rate;
+    metrics->data_notsent = info->tcpi_notsent_bytes;
+    if (info->tcpi_min_rtt != UINT32_MAX) {
+      metrics->min_rtt = info->tcpi_min_rtt;
+    }
+    metrics->packet_sent = info->tcpi_data_segs_out;
+    metrics->delivery_rate = info->tcpi_delivery_rate;
+    metrics->busy_usec = info->tcpi_busy_time;
+    metrics->rwnd_limited_usec = info->tcpi_rwnd_limited;
+    metrics->sndbuf_limited_usec = info->tcpi_sndbuf_limited;
+  }
+  if (info->length > offsetof(tcp_info, tcpi_dsack_dups)) {
+    metrics->data_sent = info->tcpi_bytes_sent;
+    metrics->data_retx = info->tcpi_bytes_retrans;
+    metrics->packet_spurious_retx = info->tcpi_dsack_dups;
+  }
+}
+
+// Extracts opt stats from the given control message \a opt_stats to the
+// connection metrics \a metrics.
+void ExtractOptStatsFromCmsg(ConnectionMetrics* metrics,
+                             const cmsghdr* opt_stats) {
+  if (opt_stats == nullptr) {
+    return;
+  }
+  const auto* data = CMSG_DATA(opt_stats);
+  constexpr int64_t cmsg_hdr_len = CMSG_ALIGN(sizeof(struct cmsghdr));
+  const int64_t len = opt_stats->cmsg_len - cmsg_hdr_len;
+  int64_t offset = 0;
+
+  while (offset < len) {
+    const auto* attr = reinterpret_cast<const nlattr*>(data + offset);
+    const void* val = data + offset + NLA_HDRLEN;
+    switch (attr->nla_type) {
+      case TCP_NLA_BUSY: {
+        metrics->busy_usec = ReadUnaligned<uint64_t>(val);
+        break;
+      }
+      case TCP_NLA_RWND_LIMITED: {
+        metrics->rwnd_limited_usec = ReadUnaligned<uint64_t>(val);
+        break;
+      }
+      case TCP_NLA_SNDBUF_LIMITED: {
+        metrics->sndbuf_limited_usec = ReadUnaligned<uint64_t>(val);
+        break;
+      }
+      case TCP_NLA_PACING_RATE: {
+        metrics->pacing_rate = ReadUnaligned<uint64_t>(val);
+        break;
+      }
+      case TCP_NLA_DELIVERY_RATE: {
+        metrics->delivery_rate = ReadUnaligned<uint64_t>(val);
+        break;
+      }
+      case TCP_NLA_DELIVERY_RATE_APP_LMT: {
+        metrics->is_delivery_rate_app_limited = ReadUnaligned<uint8_t>(val);
+        break;
+      }
+      case TCP_NLA_SND_CWND: {
+        metrics->congestion_window = ReadUnaligned<uint32_t>(val);
+        break;
+      }
+      case TCP_NLA_MIN_RTT: {
+        metrics->min_rtt = ReadUnaligned<uint32_t>(val);
+        break;
+      }
+      case TCP_NLA_SRTT: {
+        metrics->srtt = ReadUnaligned<uint32_t>(val);
+        break;
+      }
+      case TCP_NLA_RECUR_RETRANS: {
+        metrics->recurring_retrans = ReadUnaligned<uint8_t>(val);
+        break;
+      }
+      case TCP_NLA_BYTES_SENT: {
+        metrics->data_sent = ReadUnaligned<uint64_t>(val);
+        break;
+      }
+      case TCP_NLA_DATA_SEGS_OUT: {
+        metrics->packet_sent = ReadUnaligned<uint64_t>(val);
+        break;
+      }
+      case TCP_NLA_TOTAL_RETRANS: {
+        metrics->packet_retx = ReadUnaligned<uint64_t>(val);
+        break;
+      }
+      case TCP_NLA_DELIVERED: {
+        metrics->packet_delivered = ReadUnaligned<uint32_t>(val);
+        break;
+      }
+      case TCP_NLA_DELIVERED_CE: {
+        metrics->packet_delivered_ce = ReadUnaligned<uint32_t>(val);
+        break;
+      }
+      case TCP_NLA_BYTES_RETRANS: {
+        metrics->data_retx = ReadUnaligned<uint64_t>(val);
+        break;
+      }
+      case TCP_NLA_DSACK_DUPS: {
+        metrics->packet_spurious_retx = ReadUnaligned<uint32_t>(val);
+        break;
+      }
+      case TCP_NLA_REORDERING: {
+        metrics->reordering = ReadUnaligned<uint32_t>(val);
+        break;
+      }
+      case TCP_NLA_SND_SSTHRESH: {
+        metrics->snd_ssthresh = ReadUnaligned<uint32_t>(val);
+        break;
+      }
+    }
+    offset += NLA_ALIGN(attr->nla_len);
+  }
+}
+}  // namespace.
+
+bool TracedBufferList::TracedBuffer::Finished(gpr_timespec ts) {
+  constexpr int kGrpcMaxPendingAckTimeMillis = 10000;
+  return gpr_time_to_millis(gpr_time_sub(ts, last_timestamp_)) >
+         kGrpcMaxPendingAckTimeMillis;
+}
+
+void TracedBufferList::AddNewEntry(int32_t seq_no, int fd, void* arg) {
+  TracedBuffer* new_elem = new TracedBuffer(seq_no, arg);
+  // Store the current time as the sendmsg time.
+  new_elem->ts_.sendmsg_time.time = gpr_now(GPR_CLOCK_REALTIME);
+  new_elem->ts_.scheduled_time.time = gpr_inf_past(GPR_CLOCK_REALTIME);
+  new_elem->ts_.sent_time.time = gpr_inf_past(GPR_CLOCK_REALTIME);
+  new_elem->ts_.acked_time.time = gpr_inf_past(GPR_CLOCK_REALTIME);
+  if (GetSocketTcpInfo(&(new_elem->ts_.info), fd) == 0) {
+    ExtractOptStatsFromTcpInfo(&(new_elem->ts_.sendmsg_time.metrics),
+                               &(new_elem->ts_.info));
+  }
+  new_elem->last_timestamp_ = new_elem->ts_.sendmsg_time.time;
+  grpc_core::MutexLock lock(&mu_);
+  if (!head_) {
+    head_ = tail_ = new_elem;
+  } else {
+    tail_->next_ = new_elem;
+    tail_ = new_elem;
+  }
+}
+
+void TracedBufferList::ProcessTimestamp(struct sock_extended_err* serr,
+                                        struct cmsghdr* opt_stats,
+                                        struct scm_timestamping* tss) {
+  grpc_core::MutexLock lock(&mu_);
+  TracedBuffer* elem = head_;
+  TracedBuffer* prev = nullptr;
+  while (elem != nullptr) {
+    // The byte number refers to the sequence number of the last byte which this
+    // timestamp relates to.
+    if (serr->ee_data >= elem->seq_no_) {
+      switch (serr->ee_info) {
+        case SCM_TSTAMP_SCHED:
+          FillGprFromTimestamp(&(elem->ts_.scheduled_time.time), &(tss->ts[0]));
+          ExtractOptStatsFromCmsg(&(elem->ts_.scheduled_time.metrics),
+                                  opt_stats);
+          elem->last_timestamp_ = elem->ts_.scheduled_time.time;
+          elem = elem->next_;
+          break;
+        case SCM_TSTAMP_SND:
+          FillGprFromTimestamp(&(elem->ts_.sent_time.time), &(tss->ts[0]));
+          ExtractOptStatsFromCmsg(&(elem->ts_.sent_time.metrics), opt_stats);
+          elem->last_timestamp_ = elem->ts_.sent_time.time;
+          elem = elem->next_;
+          break;
+        case SCM_TSTAMP_ACK:
+          FillGprFromTimestamp(&(elem->ts_.acked_time.time), &(tss->ts[0]));
+          ExtractOptStatsFromCmsg(&(elem->ts_.acked_time.metrics), opt_stats);
+          // Got all timestamps. Do the callback and free this TracedBuffer. The
+          // thing below can be passed by value if we don't want the restriction
+          // on the lifetime.
+          g_timestamps_callback(elem->arg_, &(elem->ts_), absl::OkStatus());
+          // Safe to update head_ to elem->next_ because the list is ordered by
+          // seq_no. Thus if elem is to be deleted, it has to be the first
+          // element in the list.
+          head_ = elem->next_;
+          delete elem;
+          elem = head_;
+          break;
+        default:
+          abort();
+      }
+    } else {
+      break;
+    }
+  }
+
+  elem = head_;
+  gpr_timespec now = gpr_now(GPR_CLOCK_REALTIME);
+  while (elem != nullptr) {
+    if (!elem->Finished(now)) {
+      prev = elem;
+      elem = elem->next_;
+      continue;
+    }
+    if (prev != nullptr) {
+      prev->next_ = elem->next_;
+      delete elem;
+      elem = prev->next_;
+    } else {
+      head_ = elem->next_;
+      delete elem;
+      elem = head_;
+    }
+  }
+  tail_ = (head_ == nullptr) ? head_ : prev;
+}
+
+void TracedBufferList::Shutdown(void* remaining, absl::Status shutdown_err) {
+  grpc_core::MutexLock lock(&mu_);
+  while (head_) {
+    TracedBuffer* elem = head_;
+    g_timestamps_callback(elem->arg_, &(elem->ts_), shutdown_err);
+    head_ = head_->next_;
+    delete elem;
+  }
+  if (remaining != nullptr) {
+    g_timestamps_callback(remaining, nullptr, shutdown_err);
+  }
+  tail_ = head_;
+}
+
+void TcpSetWriteTimestampsCallback(
+    absl::AnyInvocable<void(void*, Timestamps*, absl::Status)> fn) {
+  g_timestamps_callback = std::move(fn);
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#else  // GRPC_LINUX_ERRQUEUE
+
+#include "src/core/lib/gprpp/crash.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+void TcpSetWriteTimestampsCallback(
+    absl::AnyInvocable<void(void*, Timestamps*, absl::Status)> /*fn*/) {
+  grpc_core::Crash("Timestamps callback is not enabled for this platform");
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_LINUX_ERRQUEUE

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

@@ -0,0 +1,185 @@
+// 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_TRACED_BUFFER_LIST_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TRACED_BUFFER_LIST_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stdint.h>
+
+#include "absl/functional/any_invocable.h"
+#include "absl/status/status.h"
+#include "absl/types/optional.h"
+
+#include <grpc/support/time.h>
+
+#include "src/core/lib/event_engine/posix_engine/internal_errqueue.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/iomgr/port.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+struct ConnectionMetrics {  // Delivery rate in Bytes/s.
+  absl::optional<uint64_t> delivery_rate;
+  // If the delivery rate is limited by the application, this is set to true.
+  absl::optional<bool> is_delivery_rate_app_limited;
+  // Total packets retransmitted.
+  absl::optional<uint32_t> packet_retx;
+  // Total packets retransmitted spuriously. This metric is smaller than or
+  // equal to packet_retx.
+  absl::optional<uint32_t> packet_spurious_retx;
+  // Total packets sent.
+  absl::optional<uint32_t> packet_sent;
+  // Total packets delivered.
+  absl::optional<uint32_t> packet_delivered;
+  // Total packets delivered with ECE marked. This metric is smaller than or
+  // equal to packet_delivered.
+  absl::optional<uint32_t> packet_delivered_ce;
+  // Total bytes lost so far.
+  absl::optional<uint64_t> data_retx;
+  // Total bytes sent so far.
+  absl::optional<uint64_t> data_sent;
+  // Total bytes in write queue but not sent.
+  absl::optional<uint64_t> data_notsent;
+  // Pacing rate of the connection in Bps
+  absl::optional<uint64_t> pacing_rate;
+  // Minimum RTT observed in usec.
+  absl::optional<uint32_t> min_rtt;
+  // Smoothed RTT in usec
+  absl::optional<uint32_t> srtt;
+  // Send congestion window.
+  absl::optional<uint32_t> congestion_window;
+  // Slow start threshold in packets.
+  absl::optional<uint32_t> snd_ssthresh;
+  // Maximum degree of reordering (i.e., maximum number of packets reodered)
+  // on the connection.
+  absl::optional<uint32_t> reordering;
+  // Represents the number of recurring retransmissions of the first sequence
+  // that is not acknowledged yet.
+  absl::optional<uint8_t> recurring_retrans;
+  // The cumulative time (in usec) that the transport protocol was busy
+  // sending data.
+  absl::optional<uint64_t> busy_usec;
+  // The cumulative time (in usec) that the transport protocol was limited by
+  // the receive window size.
+  absl::optional<uint64_t> rwnd_limited_usec;
+  // The cumulative time (in usec) that the transport protocol was limited by
+  // the send buffer size.
+  absl::optional<uint64_t> sndbuf_limited_usec;
+};
+
+struct BufferTimestamp {
+  gpr_timespec time;
+  ConnectionMetrics metrics;  // Metrics collected with this timestamp
+};
+
+struct Timestamps {
+  BufferTimestamp sendmsg_time;
+  BufferTimestamp scheduled_time;
+  BufferTimestamp sent_time;
+  BufferTimestamp acked_time;
+
+  uint32_t byte_offset;  // byte offset relative to the start of the RPC
+
+#ifdef GRPC_LINUX_ERRQUEUE
+  tcp_info info;  // tcp_info collected on sendmsg
+#endif            // GRPC_LINUX_ERRQUEUE
+};
+
+// TracedBuffer is a class to keep track of timestamps for a specific buffer in
+// the TCP layer. We are only tracking timestamps for Linux kernels and hence
+// this class would only be used by Linux platforms. For all other platforms,
+// TracedBuffer would be an empty class.
+// The timestamps collected are according to Timestamps declared above A
+// TracedBuffer list is kept track of using the head element of the list. If
+// *the head element of the list is nullptr, then the list is empty.
+#ifdef GRPC_LINUX_ERRQUEUE
+
+class TracedBufferList {
+ public:
+  TracedBufferList() = default;
+  ~TracedBufferList() = default;
+  // Add a new entry in the TracedBuffer list pointed to by head. Also saves
+  // sendmsg_time with the current timestamp.
+  void AddNewEntry(int32_t seq_no, int fd, void* arg);
+  // Processes a received timestamp based on sock_extended_err and
+  // scm_timestamping structures. It will invoke the timestamps callback if the
+  // timestamp type is SCM_TSTAMP_ACK.
+  void ProcessTimestamp(struct sock_extended_err* serr,
+                        struct cmsghdr* opt_stats,
+                        struct scm_timestamping* tss);
+  // The Size() operation is slow and is used only in tests.
+  int Size() {
+    grpc_core::MutexLock lock(&mu_);
+    int size = 0;
+    TracedBuffer* curr = head_;
+    while (curr) {
+      ++size;
+      curr = curr->next_;
+    }
+    return size;
+  }
+  // Cleans the list by calling the callback for each traced buffer in the list
+  // with timestamps that it has.
+  void Shutdown(void* /*remaining*/, absl::Status /*shutdown_err*/);
+
+ private:
+  class TracedBuffer {
+   public:
+    TracedBuffer(uint32_t seq_no, void* arg) : seq_no_(seq_no), arg_(arg) {}
+    // Returns true if the TracedBuffer is considered stale at the given
+    // timestamp.
+    bool Finished(gpr_timespec ts);
+
+   private:
+    friend class TracedBufferList;
+    gpr_timespec last_timestamp_;
+    TracedBuffer* next_ = nullptr;
+    uint32_t seq_no_;  // The sequence number for the last byte in the buffer
+    void* arg_;        // The arg to pass to timestamps_callback
+    Timestamps ts_;    // The timestamps corresponding to this buffer
+  };
+  grpc_core::Mutex mu_;
+  // TracedBuffers are ordered by sequence number and would need to be processed
+  // in a FIFO order starting with the smallest sequence number. To enable this,
+  // they are stored in a singly linked with head and tail pointers which allows
+  // easy appends and forward iteration operations.
+  TracedBuffer* head_ = nullptr;
+  TracedBuffer* tail_ = nullptr;
+};
+
+#else   // GRPC_LINUX_ERRQUEUE
+// TracedBufferList implementation is a no-op for this platform.
+class TracedBufferList {
+ public:
+  void AddNewEntry(int32_t /*seq_no*/, int /*fd*/, void* /*arg*/) {}
+  void ProcessTimestamp(struct sock_extended_err* /*serr*/,
+                        struct cmsghdr* /*opt_stats*/,
+                        struct scm_timestamping* /*tss*/) {}
+  int Size() { return 0; }
+  void Shutdown(void* /*remaining*/, absl::Status /*shutdown_err*/) {}
+};
+#endif  // GRPC_LINUX_ERRQUEUE
+
+// Sets the callback function to call when timestamps for a write are collected.
+// This is expected to be called atmost once.
+void TcpSetWriteTimestampsCallback(
+    absl::AnyInvocable<void(void*, Timestamps*, absl::Status)>);
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TRACED_BUFFER_LIST_H

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

@@ -0,0 +1,127 @@
+// 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 <utility>
+
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+
+#include "src/core/lib/gprpp/crash.h"  // IWYU pragma: keep
+#include "src/core/lib/iomgr/port.h"
+
+#ifdef GRPC_LINUX_EVENTFD
+
+#include <errno.h>
+#include <sys/eventfd.h>
+#include <unistd.h>
+
+#include "src/core/lib/event_engine/posix_engine/wakeup_fd_posix.h"
+#endif
+
+#include "src/core/lib/event_engine/posix_engine/wakeup_fd_eventfd.h"
+#include "src/core/lib/gprpp/strerror.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+#ifdef GRPC_LINUX_EVENTFD
+
+absl::Status EventFdWakeupFd::Init() {
+  int read_fd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
+  int write_fd = -1;
+  if (read_fd < 0) {
+    return absl::Status(absl::StatusCode::kInternal,
+                        absl::StrCat("eventfd: ", grpc_core::StrError(errno)));
+  }
+  SetWakeupFds(read_fd, write_fd);
+  return absl::OkStatus();
+}
+
+absl::Status EventFdWakeupFd::ConsumeWakeup() {
+  eventfd_t value;
+  int err;
+  do {
+    err = eventfd_read(ReadFd(), &value);
+  } while (err < 0 && errno == EINTR);
+  if (err < 0 && errno != EAGAIN) {
+    return absl::Status(
+        absl::StatusCode::kInternal,
+        absl::StrCat("eventfd_read: ", grpc_core::StrError(errno)));
+  }
+  return absl::OkStatus();
+}
+
+absl::Status EventFdWakeupFd::Wakeup() {
+  int err;
+  do {
+    err = eventfd_write(ReadFd(), 1);
+  } while (err < 0 && errno == EINTR);
+  if (err < 0) {
+    return absl::Status(
+        absl::StatusCode::kInternal,
+        absl::StrCat("eventfd_write: ", grpc_core::StrError(errno)));
+  }
+  return absl::OkStatus();
+}
+
+EventFdWakeupFd::~EventFdWakeupFd() {
+  if (ReadFd() != 0) {
+    close(ReadFd());
+  }
+}
+
+bool EventFdWakeupFd::IsSupported() {
+  EventFdWakeupFd event_fd_wakeup_fd;
+  return event_fd_wakeup_fd.Init().ok();
+}
+
+absl::StatusOr<std::unique_ptr<WakeupFd>>
+EventFdWakeupFd::CreateEventFdWakeupFd() {
+  static bool kIsEventFdWakeupFdSupported = EventFdWakeupFd::IsSupported();
+  if (kIsEventFdWakeupFdSupported) {
+    auto event_fd_wakeup_fd = std::make_unique<EventFdWakeupFd>();
+    auto status = event_fd_wakeup_fd->Init();
+    if (status.ok()) {
+      return std::unique_ptr<WakeupFd>(std::move(event_fd_wakeup_fd));
+    }
+    return status;
+  }
+  return absl::NotFoundError("Eventfd wakeup fd is not supported");
+}
+
+#else  //  GRPC_LINUX_EVENTFD
+
+#include "src/core/lib/gprpp/crash.h"
+
+absl::Status EventFdWakeupFd::Init() { grpc_core::Crash("unimplemented"); }
+
+absl::Status EventFdWakeupFd::ConsumeWakeup() {
+  grpc_core::Crash("unimplemented");
+}
+
+absl::Status EventFdWakeupFd::Wakeup() { grpc_core::Crash("unimplemented"); }
+
+bool EventFdWakeupFd::IsSupported() { return false; }
+
+absl::StatusOr<std::unique_ptr<WakeupFd>>
+EventFdWakeupFd::CreateEventFdWakeupFd() {
+  return absl::NotFoundError("Eventfd wakeup fd is not supported");
+}
+
+#endif  // GRPC_LINUX_EVENTFD
+
+}  // namespace experimental
+}  // namespace grpc_event_engine

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

@@ -0,0 +1,45 @@
+// 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_WAKEUP_FD_EVENTFD_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_EVENTFD_H
+
+#include <grpc/support/port_platform.h>
+
+#include <memory>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+
+#include "src/core/lib/event_engine/posix_engine/wakeup_fd_posix.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+class EventFdWakeupFd : public WakeupFd {
+ public:
+  EventFdWakeupFd() : WakeupFd() {}
+  ~EventFdWakeupFd() override;
+  absl::Status ConsumeWakeup() override;
+  absl::Status Wakeup() override;
+  static absl::StatusOr<std::unique_ptr<WakeupFd>> CreateEventFdWakeupFd();
+  static bool IsSupported();
+
+ private:
+  absl::Status Init();
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_EVENTFD_H