grpc 1.61.3 → 1.62.0.pre1

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.h

@@ -27,14 +27,12 @@
 
 #include <grpc/event_engine/event_engine.h>
 
-#include "src/core/lib/event_engine/ref_counted_dns_resolver_interface.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 RefCountedDNSResolverInterface {
+class NativePosixDNSResolver : public EventEngine::DNSResolver {
  public:
   explicit NativePosixDNSResolver(std::shared_ptr<EventEngine> event_engine);
 
@@ -48,8 +46,6 @@ class NativePosixDNSResolver : public RefCountedDNSResolverInterface {
   void LookupTXT(EventEngine::DNSResolver::LookupTXTCallback on_resolved,
                  absl::string_view name) override;
 
-  void Orphan() override { delete this; }
-
  private:
   std::shared_ptr<EventEngine> event_engine_;
 };

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"

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

@@ -573,8 +573,7 @@ PosixEventEngine::GetDNSResolver(
   }
   GRPC_EVENT_ENGINE_DNS_TRACE(
       "PosixEventEngine:%p creating NativePosixDNSResolver", this);
-  return std::make_unique<PosixEventEngine::PosixDNSResolver>(
-      grpc_core::MakeOrphanable<NativePosixDNSResolver>(shared_from_this()));
+  return std::make_unique<NativePosixDNSResolver>(shared_from_this());
 #endif  // GRPC_POSIX_SOCKET_RESOLVE_ADDRESS
 }
 
@@ -658,7 +657,7 @@ EventEngine::ConnectionHandle PosixEventEngine::Connect(
 #endif  // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
 }
 
-std::unique_ptr<PosixEndpointWithFdSupport>
+std::unique_ptr<EventEngine::Endpoint>
 PosixEventEngine::CreatePosixEndpointFromFd(int fd,
                                             const EndpointConfig& config,
                                             MemoryAllocator memory_allocator) {
@@ -702,7 +701,7 @@ PosixEventEngine::CreateListener(
 #endif  // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
 }
 
-absl::StatusOr<std::unique_ptr<PosixListenerWithFdSupport>>
+absl::StatusOr<std::unique_ptr<EventEngine::Listener>>
 PosixEventEngine::CreatePosixListener(
     PosixEventEngineWithFdSupport::PosixAcceptCallback on_accept,
     absl::AnyInvocable<void(absl::Status)> on_shutdown,

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

@@ -170,7 +170,7 @@ class PosixEventEngine final : public PosixEventEngineWithFdSupport,
 
   ~PosixEventEngine() override;
 
-  std::unique_ptr<PosixEndpointWithFdSupport> CreatePosixEndpointFromFd(
+  std::unique_ptr<EventEngine::Endpoint> CreatePosixEndpointFromFd(
       int fd, const EndpointConfig& config,
       MemoryAllocator memory_allocator) override;
 
@@ -181,8 +181,7 @@ class PosixEventEngine final : public PosixEventEngineWithFdSupport,
       std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory)
       override;
 
-  absl::StatusOr<std::unique_ptr<PosixListenerWithFdSupport>>
-  CreatePosixListener(
+  absl::StatusOr<std::unique_ptr<EventEngine::Listener>> CreatePosixListener(
       PosixEventEngineWithFdSupport::PosixAcceptCallback on_accept,
       absl::AnyInvocable<void(absl::Status)> on_shutdown,
       const EndpointConfig& config,

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

@@ -44,7 +44,9 @@
 #include "src/core/lib/event_engine/posix_engine/posix_engine_listener.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/gprpp/status_helper.h"
+#include "src/core/lib/gprpp/strerror.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/socket_mutator.h"
 
@@ -124,6 +126,8 @@ void PosixEngineListenerImpl::AsyncConnectionAcceptor::Start() {
 
 void PosixEngineListenerImpl::AsyncConnectionAcceptor::NotifyOnAccept(
     absl::Status status) {
+  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("Acceptor[%p]: NotifyOnAccept: %s", this,
+                                   status.ToString().c_str());
   if (!status.ok()) {
     // Shutting down the acceptor. Unref the ref grabbed in
     // AsyncConnectionAcceptor::Start().
@@ -173,7 +177,7 @@ void PosixEngineListenerImpl::AsyncConnectionAcceptor::NotifyOnAccept(
           return;
         default:
           gpr_log(GPR_ERROR, "Closing acceptor. Failed accept4: %s",
-                  strerror(errno));
+                  grpc_core::StrError(errno).c_str());
           // Shutting down the acceptor. Unref the ref grabbed in
           // AsyncConnectionAcceptor::Start().
           Unref();
@@ -186,12 +190,16 @@ void PosixEngineListenerImpl::AsyncConnectionAcceptor::NotifyOnAccept(
     if (addr.address()->sa_family == AF_UNIX) {
       socklen_t len = EventEngine::ResolvedAddress::MAX_SIZE_BYTES;
       if (getpeername(fd, const_cast<sockaddr*>(addr.address()), &len) < 0) {
-        gpr_log(GPR_ERROR, "Closing acceptor. Failed getpeername: %s",
-                strerror(errno));
+        auto listener_addr_uri = ResolvedAddressToURI(socket_.addr);
+        gpr_log(
+            GPR_ERROR,
+            "Failed getpeername: %s. Dropping the connection, and continuing "
+            "to listen on %s:%d.",
+            grpc_core::StrError(errno).c_str(),
+            listener_addr_uri.ok() ? listener_addr_uri->c_str() : "<unknown>",
+            socket_.port);
         close(fd);
-        // Shutting down the acceptor. Unref the ref grabbed in
-        // AsyncConnectionAcceptor::Start().
-        Unref();
+        handle_->NotifyOnRead(notify_on_accept_);
         return;
       }
       addr = EventEngine::ResolvedAddress(addr.address(), len);

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

@@ -249,6 +249,13 @@ absl::StatusOr<int> ListenerContainerAddAllLocalAddresses(
     return absl::FailedPreconditionError(
         absl::StrCat("getifaddrs: ", std::strerror(errno)));
   }
+
+  static const bool is_ipv4_available = [] {
+    const int fd = socket(AF_INET, SOCK_DGRAM, 0);
+    if (fd >= 0) close(fd);
+    return fd >= 0;
+  }();
+
   for (ifa_it = ifa; ifa_it != nullptr; ifa_it = ifa_it->ifa_next) {
     ResolvedAddress addr;
     socklen_t len;
@@ -256,6 +263,9 @@ absl::StatusOr<int> ListenerContainerAddAllLocalAddresses(
     if (ifa_it->ifa_addr == nullptr) {
       continue;
     } else if (ifa_it->ifa_addr->sa_family == AF_INET) {
+      if (!is_ipv4_available) {
+        continue;
+      }
       len = static_cast<socklen_t>(sizeof(sockaddr_in));
     } else if (ifa_it->ifa_addr->sa_family == AF_INET6) {
       len = static_cast<socklen_t>(sizeof(sockaddr_in6));