grpc 1.60.0 → 1.62.0

data/src/core/lib/event_engine/extensions/supports_fd.h

@@ -0,0 +1,160 @@
+// Copyright 2024 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_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_SUPPORTS_FD_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_SUPPORTS_FD_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/functional/any_invocable.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+class EndpointSupportsFdExtension {
+ public:
+  virtual ~EndpointSupportsFdExtension() = default;
+  static absl::string_view EndpointExtensionName() {
+    return "io.grpc.event_engine.extension.endpoint_supports_fd";
+  }
+  /// Returns the file descriptor associated with the posix endpoint.
+  virtual int GetWrappedFd() = 0;
+
+  /// Shutdown the endpoint. This function call should trigger execution of
+  /// any pending endpoint Read/Write callbacks with appropriate error
+  /// absl::Status. After this function call any subsequent endpoint
+  /// Read/Write operations until endpoint deletion should fail with an
+  /// appropriate absl::Status.
+  ///
+  /// \a on_release_fd - If specified, the callback is invoked when the
+  /// endpoint is destroyed/deleted. The underlying file descriptor is
+  /// released instead of being closed. The callback will get the released
+  /// file descriptor as its argument if the release operation is successful.
+  /// Otherwise it would get an appropriate error status as its argument.
+  virtual void Shutdown(absl::AnyInvocable<void(absl::StatusOr<int> release_fd)>
+                            on_release_fd) = 0;
+};
+
+class ListenerSupportsFdExtension {
+ public:
+  virtual ~ListenerSupportsFdExtension() = default;
+  static absl::string_view EndpointExtensionName() {
+    return "io.grpc.event_engine.extension.listener_supports_fd";
+  }
+  /// Called when a posix listener bind operation completes. A single bind
+  /// operation may trigger creation of multiple listener fds. This callback
+  /// should be invoked once on each newly created and bound fd. If the
+  /// corresponding bind operation fails for a particular fd, this callback
+  /// must be invoked with a absl::FailedPreConditionError status.
+  ///
+  /// \a listener_fd - The listening socket fd that was bound to the specified
+  /// address.
+  using OnPosixBindNewFdCallback =
+      absl::AnyInvocable<void(absl::StatusOr<int> listener_fd)>;
+  /// Bind an address/port to this Listener.
+  ///
+  /// It is expected that multiple addresses/ports can be bound to this
+  /// Listener before Listener::Start has been called. Returns either the
+  /// bound port or an appropriate error status.
+  /// \a addr - The address to listen for incoming connections.
+  /// \a on_bind_new_fd The callback is invoked once for each newly bound
+  /// listener fd that may be created by this Bind operation.
+  virtual absl::StatusOr<int> BindWithFd(
+      const EventEngine::ResolvedAddress& addr,
+      OnPosixBindNewFdCallback on_bind_new_fd) = 0;
+
+  /// Handle an externally accepted client connection. It must return an
+  /// appropriate error status in case of failure.
+  ///
+  /// This may be invoked to process a new client connection accepted by an
+  /// external listening fd.
+  /// \a listener_fd - The external listening socket fd that accepted the new
+  /// client connection.
+  /// \a fd - The socket file descriptor representing the new client
+  /// connection.
+  /// \a pending_data - If specified, it holds any pending data that may have
+  /// already been read over the externally accepted client connection.
+  /// Otherwise, it is assumed that no data has been read over the new client
+  /// connection.
+  virtual absl::Status HandleExternalConnection(int listener_fd, int fd,
+                                                SliceBuffer* pending_data) = 0;
+
+  /// Shutdown/stop listening on all bind Fds.
+  virtual void ShutdownListeningFds() = 0;
+};
+
+class EventEngineSupportsFdExtension {
+ public:
+  virtual ~EventEngineSupportsFdExtension() = default;
+  static absl::string_view EndpointExtensionName() {
+    return "io.grpc.event_engine.extension.event_engine_supports_fd";
+  }
+  /// Creates a posix specific EventEngine::Endpoint from an fd which is already
+  /// assumed to be connected to a remote peer. \a fd - The connected socket
+  /// file descriptor. \a config - Additional configuration to applied to the
+  /// endpoint. \a memory_allocator - The endpoint may use the provided memory
+  /// allocator to track memory allocations.
+  virtual std::unique_ptr<EventEngine::Endpoint> CreatePosixEndpointFromFd(
+      int fd, const EndpointConfig& config,
+      MemoryAllocator memory_allocator) = 0;
+
+  /// Called when the posix listener has accepted a new client connection.
+  /// \a listener_fd - The listening socket fd that accepted the new client
+  /// connection.
+  /// \a endpoint - The EventEngine endpoint to handle data exchange over the
+  /// new client connection.
+  /// \a is_external - A boolean indicating whether the new client connection
+  /// is accepted by an external listener_fd or by a listener_fd that is
+  /// managed by the EventEngine listener.
+  /// \a memory_allocator - The callback may use the provided memory
+  /// allocator to handle memory allocation operations.
+  /// \a pending_data - If specified, it holds any pending data that may have
+  /// already been read over the new client connection. Otherwise, it is
+  /// assumed that no data has been read over the new client connection.
+  using PosixAcceptCallback = absl::AnyInvocable<void(
+      int listener_fd, std::unique_ptr<EventEngine::Endpoint> endpoint,
+      bool is_external, MemoryAllocator memory_allocator,
+      SliceBuffer* pending_data)>;
+
+  /// Factory method to create a posix specific network listener / server with
+  /// fd support.
+  ///
+  /// Once a \a Listener is created and started, the \a on_accept callback will
+  /// be called once asynchronously for each established connection. This method
+  /// may return a non-OK status immediately if an error was encountered in any
+  /// synchronous steps required to create the Listener. In this case,
+  /// \a on_shutdown will never be called.
+  ///
+  /// If this method returns a Listener, then \a on_shutdown will be invoked
+  /// exactly once, when the Listener is shut down. The status passed to it will
+  /// indicate if there was a problem during shutdown.
+  ///
+  /// The provided \a MemoryAllocatorFactory is used to create \a
+  /// MemoryAllocators for Endpoint construction.
+  virtual absl::StatusOr<std::unique_ptr<EventEngine::Listener>>
+  CreatePosixListener(
+      PosixAcceptCallback on_accept,
+      absl::AnyInvocable<void(absl::Status)> on_shutdown,
+      const EndpointConfig& config,
+      std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory) = 0;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_SUPPORTS_FD_H

data/src/core/lib/event_engine/forkable.cc

@@ -43,13 +43,15 @@ bool IsForkEnabled() {
 void ObjectGroupForkHandler::RegisterForkable(
     std::shared_ptr<Forkable> forkable, GRPC_UNUSED void (*prepare)(void),
     GRPC_UNUSED void (*parent)(void), GRPC_UNUSED void (*child)(void)) {
-  GPR_ASSERT(!is_forking_);
-  forkables_.emplace_back(forkable);
+  if (IsForkEnabled()) {
+    GPR_ASSERT(!is_forking_);
+    forkables_.emplace_back(forkable);
 #ifdef GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK
-  if (!std::exchange(registered_, true)) {
-    pthread_atfork(prepare, parent, child);
-  }
+    if (!std::exchange(registered_, true)) {
+      pthread_atfork(prepare, parent, child);
+    }
 #endif  // GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK
+  }
 }
 
 void ObjectGroupForkHandler::Prefork() {

data/src/core/lib/event_engine/posix.h

@@ -16,145 +16,34 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <memory>
-
-#include "absl/functional/any_invocable.h"
-#include "absl/status/status.h"
-#include "absl/status/statusor.h"
-
 #include <grpc/event_engine/endpoint_config.h>
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/event_engine/memory_allocator.h>
 #include <grpc/event_engine/slice_buffer.h>
 
+#include "src/core/lib/event_engine/extensions/can_track_errors.h"
+#include "src/core/lib/event_engine/extensions/supports_fd.h"
+#include "src/core/lib/event_engine/query_extensions.h"
+
 namespace grpc_event_engine {
 namespace experimental {
 
 /// This defines an interface that posix specific EventEngines endpoints
 /// may implement to support additional file descriptor related functionality.
-class PosixEndpointWithFdSupport : public EventEngine::Endpoint {
- public:
-  /// Returns the file descriptor associated with the posix endpoint.
-  virtual int GetWrappedFd() = 0;
-
-  /// Returns if the Endpoint supports tracking events from errmsg queues on
-  /// posix systems.
-  virtual bool CanTrackErrors() = 0;
-
-  /// Shutdown the endpoint. This function call should trigger execution of
-  /// any pending endpoint Read/Write callbacks with appropriate error
-  /// absl::Status. After this function call any subsequent endpoint
-  /// Read/Write operations until endpoint deletion should fail with an
-  /// appropriate absl::Status.
-  ///
-  /// \a on_release_fd - If specifed, the callback is invoked when the
-  /// endpoint is destroyed/deleted. The underlying file descriptor is
-  /// released instead of being closed. The callback will get the released
-  /// file descriptor as its argument if the release operation is successful.
-  /// Otherwise it would get an appropriate error status as its argument.
-  virtual void Shutdown(absl::AnyInvocable<void(absl::StatusOr<int> release_fd)>
-                            on_release_fd) = 0;
-};
+class PosixEndpointWithFdSupport
+    : public ExtendedType<EventEngine::Endpoint, EndpointSupportsFdExtension,
+                          EndpointCanTrackErrorsExtension> {};
 
 /// Defines an interface that posix EventEngine listeners may implement to
 /// support additional file descriptor related functionality.
-class PosixListenerWithFdSupport : public EventEngine::Listener {
- public:
-  /// Called when a posix listener bind operation completes. A single bind
-  /// operation may trigger creation of multiple listener fds. This callback
-  /// should be invoked once on each newly created and bound fd. If the
-  /// corresponding bind operation fails for a particular fd, this callback
-  /// must be invoked with a absl::FailedPreConditionError status.
-  ///
-  /// \a listener_fd - The listening socket fd that was bound to the specified
-  /// address.
-  using OnPosixBindNewFdCallback =
-      absl::AnyInvocable<void(absl::StatusOr<int> listener_fd)>;
-  /// Bind an address/port to this Listener.
-  ///
-  /// It is expected that multiple addresses/ports can be bound to this
-  /// Listener before Listener::Start has been called. Returns either the
-  /// bound port or an appropriate error status.
-  /// \a addr - The address to listen for incoming connections.
-  /// \a on_bind_new_fd The callback is invoked once for each newly bound
-  /// listener fd that may be created by this Bind operation.
-  virtual absl::StatusOr<int> BindWithFd(
-      const EventEngine::ResolvedAddress& addr,
-      OnPosixBindNewFdCallback on_bind_new_fd) = 0;
-
-  /// Handle an externally accepted client connection. It must return an
-  /// appropriate error status in case of failure.
-  ///
-  /// This may be invoked to process a new client connection accepted by an
-  /// external listening fd.
-  /// \a listener_fd - The external listening socket fd that accepted the new
-  /// client connection.
-  /// \a fd - The socket file descriptor representing the new client
-  /// connection.
-  /// \a pending_data - If specified, it holds any pending data that may have
-  /// already been read over the externally accepted client connection.
-  /// Otherwise, it is assumed that no data has been read over the new client
-  /// connection.
-  virtual absl::Status HandleExternalConnection(int listener_fd, int fd,
-                                                SliceBuffer* pending_data) = 0;
-
-  /// Shutdown/stop listening on all bind Fds.
-  virtual void ShutdownListeningFds() = 0;
+class PosixListenerWithFdSupport
+    : public ExtendedType<EventEngine::Listener, ListenerSupportsFdExtension> {
 };
 
 /// Defines an interface that posix EventEngines may implement to
 /// support additional file descriptor related functionality.
-class PosixEventEngineWithFdSupport : public EventEngine {
- public:
-  /// Creates a posix specific EventEngine::Endpoint from an fd which is already
-  /// assumed to be connected to a remote peer. \a fd - The connected socket
-  /// file descriptor. \a config - Additional configuration to applied to the
-  /// endpoint. \a memory_allocator - The endpoint may use the provided memory
-  /// allocator to track memory allocations.
-  virtual std::unique_ptr<PosixEndpointWithFdSupport> CreatePosixEndpointFromFd(
-      int fd, const EndpointConfig& config,
-      MemoryAllocator memory_allocator) = 0;
-
-  /// Called when the posix listener has accepted a new client connection.
-  /// \a listener_fd - The listening socket fd that accepted the new client
-  /// connection.
-  /// \a endpoint - The EventEngine endpoint to handle data exchange over the
-  /// new client connection.
-  /// \a is_external - A boolean indicating whether the new client connection
-  /// is accepted by an external listener_fd or by a listener_fd that is
-  /// managed by the EventEngine listener.
-  /// \a memory_allocator - The callback may use the provided memory
-  /// allocator to handle memory allocation operations.
-  /// \a pending_data - If specified, it holds any pending data that may have
-  /// already been read over the new client connection. Otherwise, it is
-  /// assumed that no data has been read over the new client connection.
-  using PosixAcceptCallback = absl::AnyInvocable<void(
-      int listener_fd, std::unique_ptr<EventEngine::Endpoint> endpoint,
-      bool is_external, MemoryAllocator memory_allocator,
-      SliceBuffer* pending_data)>;
-
-  /// Factory method to create a posix specific network listener / server with
-  /// fd support.
-  ///
-  /// Once a \a Listener is created and started, the \a on_accept callback will
-  /// be called once asynchronously for each established connection. This method
-  /// may return a non-OK status immediately if an error was encountered in any
-  /// synchronous steps required to create the Listener. In this case,
-  /// \a on_shutdown will never be called.
-  ///
-  /// If this method returns a Listener, then \a on_shutdown will be invoked
-  /// exactly once, when the Listener is shut down. The status passed to it will
-  /// indicate if there was a problem during shutdown.
-  ///
-  /// The provided \a MemoryAllocatorFactory is used to create \a
-  /// MemoryAllocators for Endpoint construction.
-  virtual absl::StatusOr<std::unique_ptr<PosixListenerWithFdSupport>>
-  CreatePosixListener(
-      PosixAcceptCallback on_accept,
-      absl::AnyInvocable<void(absl::Status)> on_shutdown,
-      const EndpointConfig& config,
-      std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory) = 0;
-};
+class PosixEventEngineWithFdSupport
+    : public ExtendedType<EventEngine, EventEngineSupportsFdExtension> {};
 
 }  // namespace experimental
 }  // namespace grpc_event_engine

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

@@ -0,0 +1,132 @@
+// Copyright 2023 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/iomgr/port.h"
+
+#ifdef GRPC_POSIX_SOCKET_RESOLVE_ADDRESS
+
+#include <netdb.h>
+#include <string.h>
+#include <sys/socket.h>
+
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "absl/functional/any_invocable.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
+
+#include "src/core/lib/event_engine/posix_engine/native_posix_dns_resolver.h"
+#include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/host_port.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+namespace {
+
+absl::StatusOr<std::vector<EventEngine::ResolvedAddress>>
+LookupHostnameBlocking(absl::string_view name, absl::string_view default_port) {
+  struct addrinfo hints;
+  struct addrinfo *result = nullptr, *resp;
+  std::string host;
+  std::string port;
+  // parse name, splitting it into host and port parts
+  grpc_core::SplitHostPort(name, &host, &port);
+  if (host.empty()) {
+    return absl::InvalidArgumentError(absl::StrCat("Unparseable name: ", name));
+  }
+  if (port.empty()) {
+    if (default_port.empty()) {
+      return absl::InvalidArgumentError(
+          absl::StrFormat("No port in name %s or default_port argument", name));
+    }
+    port = std::string(default_port);
+  }
+  // Call getaddrinfo
+  memset(&hints, 0, sizeof(hints));
+  hints.ai_family = AF_UNSPEC;      // ipv4 or ipv6
+  hints.ai_socktype = SOCK_STREAM;  // stream socket
+  hints.ai_flags = AI_PASSIVE;      // for wildcard IP address
+  int s = getaddrinfo(host.c_str(), port.c_str(), &hints, &result);
+  if (s != 0) {
+    // Retry if well-known service name is recognized
+    const char* svc[][2] = {{"http", "80"}, {"https", "443"}};
+    for (size_t i = 0; i < GPR_ARRAY_SIZE(svc); i++) {
+      if (port == svc[i][0]) {
+        s = getaddrinfo(host.c_str(), svc[i][1], &hints, &result);
+        break;
+      }
+    }
+  }
+  if (s != 0) {
+    return absl::UnknownError(absl::StrFormat(
+        "Address lookup failed for %s os_error: %s syscall: getaddrinfo", name,
+        gai_strerror(s)));
+  }
+  // Success path: fill in addrs
+  std::vector<EventEngine::ResolvedAddress> addresses;
+  for (resp = result; resp != nullptr; resp = resp->ai_next) {
+    addresses.emplace_back(resp->ai_addr, resp->ai_addrlen);
+  }
+  if (result) {
+    freeaddrinfo(result);
+  }
+  return addresses;
+}
+
+}  // namespace
+
+NativePosixDNSResolver::NativePosixDNSResolver(
+    std::shared_ptr<EventEngine> event_engine)
+    : event_engine_(std::move(event_engine)) {}
+
+void NativePosixDNSResolver::LookupHostname(
+    EventEngine::DNSResolver::LookupHostnameCallback on_resolved,
+    absl::string_view name, absl::string_view default_port) {
+  event_engine_->Run(
+      [name, default_port, on_resolved = std::move(on_resolved)]() mutable {
+        on_resolved(LookupHostnameBlocking(name, default_port));
+      });
+}
+
+void NativePosixDNSResolver::LookupSRV(
+    EventEngine::DNSResolver::LookupSRVCallback on_resolved,
+    absl::string_view /* name */) {
+  // Not supported
+  event_engine_->Run([on_resolved = std::move(on_resolved)]() mutable {
+    on_resolved(absl::UnimplementedError(
+        "The Native resolver does not support looking up SRV records"));
+  });
+}
+
+void NativePosixDNSResolver::LookupTXT(
+    EventEngine::DNSResolver::LookupTXTCallback on_resolved,
+    absl::string_view /* name */) {
+  // Not supported
+  event_engine_->Run([on_resolved = std::move(on_resolved)]() mutable {
+    on_resolved(absl::UnimplementedError(
+        "The Native resolver does not support looking up TXT records"));
+  });
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_POSIX_SOCKET_RESOLVE_ADDRESS

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

@@ -0,0 +1,57 @@
+// Copyright 2023 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_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_NATIVE_POSIX_DNS_RESOLVER_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_NATIVE_POSIX_DNS_RESOLVER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <memory>
+
+#include "absl/strings/string_view.h"
+
+#include "src/core/lib/iomgr/port.h"
+
+#ifdef GRPC_POSIX_SOCKET_RESOLVE_ADDRESS
+
+#include <grpc/event_engine/event_engine.h>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+// An asynchronous DNS resolver which uses the native platform's getaddrinfo
+// API. Only supports A/AAAA records.
+class NativePosixDNSResolver : public EventEngine::DNSResolver {
+ public:
+  explicit NativePosixDNSResolver(std::shared_ptr<EventEngine> event_engine);
+
+  void LookupHostname(
+      EventEngine::DNSResolver::LookupHostnameCallback on_resolved,
+      absl::string_view name, absl::string_view default_port) override;
+
+  void LookupSRV(EventEngine::DNSResolver::LookupSRVCallback on_resolved,
+                 absl::string_view name) override;
+
+  void LookupTXT(EventEngine::DNSResolver::LookupTXTCallback on_resolved,
+                 absl::string_view name) override;
+
+ private:
+  std::shared_ptr<EventEngine> event_engine_;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_POSIX_SOCKET_RESOLVE_ADDRESS
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_NATIVE_POSIX_DNS_RESOLVER_H

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

@@ -43,6 +43,7 @@
 #include "src/core/lib/event_engine/posix_engine/internal_errqueue.h"
 #include "src/core/lib/event_engine/posix_engine/tcp_socket_utils.h"
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
+#include "src/core/lib/event_engine/trace.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/load_file.h"
@@ -576,6 +577,7 @@ void PosixEndpointImpl::HandleRead(absl::Status status) {
     grpc_core::MutexLock lock(&read_mu_);
     ret = HandleReadLocked(status);
     if (ret) {
+      GRPC_EVENT_ENGINE_ENDPOINT_TRACE("Endpoint[%p]: Read complete", this);
       cb = std::move(read_cb_);
       read_cb_ = nullptr;
       incoming_buffer_ = nullptr;
@@ -593,6 +595,7 @@ bool PosixEndpointImpl::Read(absl::AnyInvocable<void(absl::Status)> on_read,
                              SliceBuffer* buffer,
                              const EventEngine::Endpoint::ReadArgs* args) {
   grpc_core::ReleasableMutexLock lock(&read_mu_);
+  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("Endpoint[%p]: Read", this);
   GPR_ASSERT(read_cb_ == nullptr);
   incoming_buffer_ = buffer;
   incoming_buffer_->Clear();
@@ -633,7 +636,10 @@ bool PosixEndpointImpl::Read(absl::AnyInvocable<void(absl::Status)> on_read,
       // Read failed immediately. Schedule the on_read callback to run
       // asynchronously.
       lock.Release();
-      engine_->Run([on_read = std::move(on_read), status]() mutable {
+      engine_->Run([on_read = std::move(on_read), status, this]() mutable {
+        GRPC_EVENT_ENGINE_ENDPOINT_TRACE(
+            "Endpoint[%p]: Read failed immediately: %s", this,
+            status.ToString().c_str());
         on_read(status);
       });
       Unref();
@@ -643,6 +649,8 @@ bool PosixEndpointImpl::Read(absl::AnyInvocable<void(absl::Status)> on_read,
     // callback.
     incoming_buffer_ = nullptr;
     Unref();
+    GRPC_EVENT_ENGINE_ENDPOINT_TRACE("Endpoint[%p]: Read succeeded immediately",
+                                     this);
     return true;
   }
   return false;
@@ -1116,6 +1124,8 @@ bool PosixEndpointImpl::TcpFlush(absl::Status& status) {
 
 void PosixEndpointImpl::HandleWrite(absl::Status status) {
   if (!status.ok()) {
+    GRPC_EVENT_ENGINE_ENDPOINT_TRACE("Endpoint[%p]: Write failed: %s", this,
+                                     status.ToString().c_str());
     absl::AnyInvocable<void(absl::Status)> cb_ = std::move(write_cb_);
     write_cb_ = nullptr;
     if (current_zerocopy_send_ != nullptr) {
@@ -1133,6 +1143,8 @@ void PosixEndpointImpl::HandleWrite(absl::Status status) {
     GPR_DEBUG_ASSERT(status.ok());
     handle_->NotifyOnWrite(on_write_);
   } else {
+    GRPC_EVENT_ENGINE_ENDPOINT_TRACE("Endpoint[%p]: Write complete: %s", this,
+                                     status.ToString().c_str());
     absl::AnyInvocable<void(absl::Status)> cb_ = std::move(write_cb_);
     write_cb_ = nullptr;
     current_zerocopy_send_ = nullptr;
@@ -1151,15 +1163,22 @@ bool PosixEndpointImpl::Write(
   GPR_DEBUG_ASSERT(current_zerocopy_send_ == nullptr);
   GPR_DEBUG_ASSERT(data != nullptr);
 
+  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("Endpoint[%p]: Write %" PRIdPTR " bytes",
+                                   this, data->Length());
+
   if (data->Length() == 0) {
     TcpShutdownTracedBufferList();
     if (handle_->IsHandleShutdown()) {
       status = TcpAnnotateError(absl::InternalError("EOF"));
-      engine_->Run([on_writable = std::move(on_writable), status]() mutable {
-        on_writable(status);
-      });
+      engine_->Run(
+          [on_writable = std::move(on_writable), status, this]() mutable {
+            GRPC_EVENT_ENGINE_ENDPOINT_TRACE("Endpoint[%p]: Write failed: %s",
+                                             this, status.ToString().c_str());
+            on_writable(status);
+          });
       return false;
     }
+    GRPC_EVENT_ENGINE_ENDPOINT_TRACE("Endpoint[%p]: Write skipped", this);
     return true;
   }
 
@@ -1189,13 +1208,18 @@ bool PosixEndpointImpl::Write(
   if (!status.ok()) {
     // Write failed immediately. Schedule the on_writable callback to run
     // asynchronously.
-    engine_->Run([on_writable = std::move(on_writable), status]() mutable {
-      on_writable(status);
-    });
+    engine_->Run(
+        [on_writable = std::move(on_writable), status, this]() mutable {
+          GRPC_EVENT_ENGINE_ENDPOINT_TRACE("Endpoint[%p]: Write failed: %s",
+                                           this, status.ToString().c_str());
+          on_writable(status);
+        });
     return false;
   }
   // Write succeeded immediately. Return true and don't run the on_writable
   // callback.
+  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("Endpoint[%p]: Write succeded immediately",
+                                   this);
   return true;
 }
 

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

@@ -38,6 +38,7 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/event_engine/extensions/supports_fd.h"
 #include "src/core/lib/event_engine/posix.h"
 #include "src/core/lib/event_engine/posix_engine/event_poller.h"
 #include "src/core/lib/event_engine/posix_engine/posix_engine_closure.h"