grpc 1.73.0 → 1.75.0

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

@@ -27,11 +27,12 @@
 
 #include "absl/base/thread_annotations.h"
 #include "absl/container/flat_hash_map.h"
+#include "absl/container/inlined_vector.h"
 #include "absl/functional/any_invocable.h"
-#include "absl/hash/hash.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
+#include "src/core/lib/event_engine/ares_resolver.h"
 #include "src/core/lib/event_engine/handle_containers.h"
 #include "src/core/lib/event_engine/posix.h"
 #include "src/core/lib/event_engine/posix_engine/event_poller.h"
@@ -39,7 +40,6 @@
 #include "src/core/lib/event_engine/ref_counted_dns_resolver_interface.h"
 #include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/iomgr/port.h"
-#include "src/core/lib/surface/init_internally.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/sync.h"
 
@@ -48,6 +48,13 @@
 #include "src/core/lib/event_engine/posix_engine/tcp_socket_utils.h"
 #endif  // GRPC_POSIX_SOCKET_TCP
 
+#if defined(GRPC_POSIX_SOCKET_TCP) && \
+    !defined(GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER)
+#define GRPC_PLATFORM_SUPPORTS_POSIX_POLLING true
+#else
+#define GRPC_PLATFORM_SUPPORTS_POSIX_POLLING false
+#endif
+
 namespace grpc_event_engine::experimental {
 
 #ifdef GRPC_POSIX_SOCKET_TCP
@@ -94,45 +101,11 @@ class AsyncConnect {
   bool connect_cancelled_;
 };
 
-// A helper class to manager lifetime of the poller associated with the
-// posix EventEngine.
-class PosixEnginePollerManager
-    : public grpc_event_engine::experimental::Scheduler {
- public:
-  explicit PosixEnginePollerManager(std::shared_ptr<ThreadPool> executor);
-  explicit PosixEnginePollerManager(
-      std::shared_ptr<grpc_event_engine::experimental::PosixEventPoller>
-          poller);
-  grpc_event_engine::experimental::PosixEventPoller* Poller() {
-    return poller_.get();
-  }
-
-  ThreadPool* Executor() { return executor_.get(); }
-
-  void Run(experimental::EventEngine::Closure* closure) override;
-  void Run(absl::AnyInvocable<void()>) override;
-
-  bool IsShuttingDown() {
-    return poller_state_.load(std::memory_order_acquire) ==
-           PollerState::kShuttingDown;
-  }
-  void TriggerShutdown();
-
-  ~PosixEnginePollerManager() override;
-
- private:
-  enum class PollerState { kExternal, kOk, kShuttingDown };
-  std::shared_ptr<grpc_event_engine::experimental::PosixEventPoller> poller_;
-  std::atomic<PollerState> poller_state_{PollerState::kOk};
-  std::shared_ptr<ThreadPool> executor_;
-  bool trigger_shutdown_called_;
-};
 #endif  // GRPC_POSIX_SOCKET_TCP
 
 // An iomgr-based Posix EventEngine implementation.
 // All methods require an ExecCtx to already exist on the thread's stack.
-class PosixEventEngine final : public PosixEventEngineWithFdSupport,
-                               public grpc_core::KeepsGrpcInitialized {
+class PosixEventEngine final : public PosixEventEngineWithFdSupport {
  public:
   class PosixDNSResolver : public EventEngine::DNSResolver {
    public:
@@ -198,6 +171,13 @@ class PosixEventEngine final : public PosixEventEngineWithFdSupport,
   bool Cancel(TaskHandle handle) override;
 
 #ifdef GRPC_POSIX_SOCKET_TCP
+
+#ifdef GRPC_ENABLE_FORK_SUPPORT
+  enum class OnForkRole { kChild, kParent };
+  void AfterFork(OnForkRole on_fork_role);
+  void BeforeFork();
+#endif  // GRPC_ENABLE_FORK_SUPPORT
+
   // The posix EventEngine returned by this method would have a shared ownership
   // of the poller and would not be in-charge of driving the poller by calling
   // its Work(..) method. Instead its upto the test to drive the poller. The
@@ -209,19 +189,19 @@ class PosixEventEngine final : public PosixEventEngineWithFdSupport,
 #endif  // GRPC_POSIX_SOCKET_TCP
 
  private:
+  friend class AresResolverTest;
   struct ClosureData;
 
   PosixEventEngine();
 
-#ifdef GRPC_POSIX_SOCKET_TCP
-  // Constructs an EventEngine which has a shared ownership of the poller. Do
-  // not call this constructor directly. Instead use the
-  // MakeTestOnlyPosixEventEngine static method. Its expected to be used only in
-  // tests.
+#if GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
+  // Constructs an EventEngine which has a shared ownership of the poller. Use
+  // the MakeTestOnlyPosixEventEngine static method to call this. Its expected
+  // to be used only in tests.
   explicit PosixEventEngine(
       std::shared_ptr<grpc_event_engine::experimental::PosixEventPoller>
           poller);
-#endif  // GRPC_POSIX_SOCKET_TCP
+#endif  // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
 
   EventEngine::TaskHandle RunAfterInternal(Duration when,
                                            absl::AnyInvocable<void()> cb);
@@ -234,11 +214,8 @@ class PosixEventEngine final : public PosixEventEngineWithFdSupport,
         ABSL_GUARDED_BY(&mu);
   };
 
-  static void PollerWorkInternal(
-      std::shared_ptr<PosixEnginePollerManager> poller_manager);
-
   ConnectionHandle CreateEndpointFromUnconnectedFdInternal(
-      int fd, EventEngine::OnConnectCallback on_connect,
+      const FileDescriptor& fd, EventEngine::OnConnectCallback on_connect,
       const EventEngine::ResolvedAddress& addr, const PosixTcpOptions& options,
       MemoryAllocator memory_allocator, EventEngine::Duration timeout);
 
@@ -249,14 +226,65 @@ class PosixEventEngine final : public PosixEventEngineWithFdSupport,
 
 #endif  // GRPC_POSIX_SOCKET_TCP
 
+#if GRPC_ENABLE_FORK_SUPPORT
+  void AfterForkInChild();
+#endif
+
   grpc_core::Mutex mu_;
   TaskHandleSet known_handles_ ABSL_GUARDED_BY(mu_);
   std::atomic<intptr_t> aba_token_{0};
+#if GRPC_ARES == 1 && defined(GRPC_POSIX_SOCKET_ARES_EV_DRIVER)
+
+  void RegisterAresResolverForFork(AresResolver* resolver);
+
+#if GRPC_ENABLE_FORK_SUPPORT
+  // A separate mutex to avoid deadlocks.
+  grpc_core::Mutex resolver_handles_mu_;
+  absl::InlinedVector<std::weak_ptr<AresResolver::ReinitHandle>, 16>
+      resolver_handles_ ABSL_GUARDED_BY(resolver_handles_mu_);
+#endif  // GRPC_ENABLE_FORK_SUPPORT
+#endif  // GRPC_ARES == 1 && defined(GRPC_POSIX_SOCKET_ARES_EV_DRIVER)
   std::shared_ptr<ThreadPool> executor_;
+
+#if GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
+
+  // RAII wrapper for a polling cycle. Starts a new one in ctor and stops
+  // in dtor.
+  class PollingCycle {
+   public:
+    explicit PollingCycle(
+        std::shared_ptr<ThreadPool> executor,
+        std::shared_ptr<grpc_event_engine::experimental::PosixEventPoller>
+            poller);
+    ~PollingCycle();
+
+   private:
+    void PollerWorkInternal();
+
+    std::shared_ptr<ThreadPool> executor_;
+    std::shared_ptr<grpc_event_engine::experimental::PosixEventPoller> poller_;
+    grpc_core::Mutex mu_;
+    std::atomic_bool done_{false};
+    int is_scheduled_ ABSL_GUARDED_BY(&mu_) = 0;
+    grpc_core::CondVar cond_;
+  };
+
+  void SchedulePoller();
+  void ResetPollCycle();
+
+  PosixEventPoller* GetPollerChecked() const {
+    CHECK_NE(poller_, nullptr);
+    return poller_.get();
+  }
+
+  std::shared_ptr<grpc_event_engine::experimental::PosixEventPoller> poller_;
+
+  // Ensures there's ever only one of these.
+  std::optional<PollingCycle> polling_cycle_ ABSL_GUARDED_BY(&mu_);
+
+#endif  // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
+
   std::shared_ptr<TimerManager> timer_manager_;
-#ifdef GRPC_POSIX_SOCKET_TCP
-  std::shared_ptr<PosixEnginePollerManager> poller_manager_;
-#endif  // GRPC_POSIX_SOCKET_TCP
 };
 
 }  // namespace grpc_event_engine::experimental

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

@@ -30,7 +30,6 @@
 #include <optional>
 #include <string>
 #include <tuple>
-#include <type_traits>
 #include <utility>
 
 #include "absl/functional/any_invocable.h"
@@ -42,9 +41,10 @@
 #include "src/core/lib/event_engine/posix_engine/event_poller.h"
 #include "src/core/lib/event_engine/posix_engine/posix_endpoint.h"
 #include "src/core/lib/event_engine/posix_engine/posix_engine_listener.h"
+#include "src/core/lib/event_engine/posix_engine/posix_interface.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/iomgr/socket_mutator.h"
+#include "src/core/net/socket_mutator.h"
 #include "src/core/util/status_helper.h"
 #include "src/core/util/strerror.h"
 #include "src/core/util/time.h"
@@ -80,16 +80,15 @@ absl::StatusOr<int> PosixEngineListenerImpl::Bind(
   CHECK(addr.size() <= EventEngine::ResolvedAddress::MAX_SIZE_BYTES);
   UnlinkIfUnixDomainSocket(addr);
 
+  EventEnginePosixInterface& posix_interface = poller_->posix_interface();
+
   /// Check if this is a wildcard port, and if so, try to keep the port the same
   /// as some previously created listener socket.
   for (auto it = acceptors_.begin();
        requested_port == 0 && it != acceptors_.end(); it++) {
-    EventEngine::ResolvedAddress sockname_temp;
-    socklen_t len = static_cast<socklen_t>(sizeof(struct sockaddr_storage));
-    if (0 == getsockname((*it)->Socket().sock.Fd(),
-                         const_cast<sockaddr*>(sockname_temp.address()),
-                         &len)) {
-      int used_port = ResolvedAddressGetPort(sockname_temp);
+    auto sockname_temp = posix_interface.LocalAddress((*it)->Fd());
+    if (sockname_temp.ok()) {
+      int used_port = ResolvedAddressGetPort(*sockname_temp);
       if (used_port > 0) {
         requested_port = used_port;
         ResolvedAddressSetPort(res_addr, requested_port);
@@ -97,21 +96,21 @@ absl::StatusOr<int> PosixEngineListenerImpl::Bind(
       }
     }
   }
-
   auto used_port = MaybeGetWildcardPortFromAddress(res_addr);
   // Update the callback. Any subsequent new sockets created and added to
   // acceptors_ in this function will invoke the new callback.
   acceptors_.UpdateOnAppendCallback(std::move(on_bind_new_fd));
   if (used_port.has_value()) {
     requested_port = *used_port;
-    return ListenerContainerAddWildcardAddresses(acceptors_, options_,
-                                                 requested_port);
+    return ListenerContainerAddWildcardAddresses(&posix_interface, acceptors_,
+                                                 options_, requested_port);
   }
   if (ResolvedAddressToV4Mapped(res_addr, &addr6_v4mapped)) {
     res_addr = addr6_v4mapped;
   }
 
-  auto result = CreateAndPrepareListenerSocket(options_, res_addr);
+  auto result =
+      CreateAndPrepareListenerSocket(&posix_interface, options_, res_addr);
   GRPC_RETURN_IF_ERROR(result.status());
   acceptors_.Append(*result);
   return result->port;
@@ -136,22 +135,31 @@ void PosixEngineListenerImpl::AsyncConnectionAcceptor::NotifyOnAccept(
   for (;;) {
     EventEngine::ResolvedAddress addr;
     memset(const_cast<sockaddr*>(addr.address()), 0, addr.size());
+    auto& posix_interface = handle_->Poller()->posix_interface();
     // Note: If we ever decide to return this address to the user, remember to
     // strip off the ::ffff:0.0.0.0/96 prefix first.
-    int fd = Accept4(handle_->WrappedFd(), addr, 1, 1);
-    if (fd < 0) {
-      switch (errno) {
+    auto fd = posix_interface.Accept4(handle_->WrappedFd(), addr, 1, 1);
+    if (fd.IsWrongGenerationError()) {
+      LOG(ERROR) << "Closing acceptor. accept4 was called with fd from a wrong "
+                    "generation";
+      // Shutting down the acceptor. Unref the ref grabbed in
+      // AsyncConnectionAcceptor::Start().
+      Unref();
+      return;
+    }
+    if (fd.IsPosixError()) {
+      switch (*fd.errno_value()) {
         case EINTR:
           continue;
         case EMFILE:
-          // When the process runs out of fds, accept4() returns EMFILE. When
-          // this happens, the connection is left in the accept queue until
-          // either a read event triggers the on_read callback, or time has
-          // passed and the accept should be re-tried regardless. This callback
-          // is not cancelled, so a spurious wakeup may occur even when there's
-          // nothing to accept. This is not a performant code path, but if an fd
-          // limit has been reached, the system is likely in an unhappy state
-          // regardless.
+          // When the process runs out of posix_interface, accept4() returns
+          // EMFILE. When this happens, the connection is left in the accept
+          // queue until either a read event triggers the on_read callback, or
+          // time has passed and the accept should be re-tried regardless. This
+          // callback is not cancelled, so a spurious wakeup may occur even when
+          // there's nothing to accept. This is not a performant code path, but
+          // if an fd limit has been reached, the system is likely in an unhappy
+          // state regardless.
           LOG_EVERY_N_SEC(ERROR, 1)
               << "File descriptor limit reached. Retrying.";
           handle_->NotifyOnRead(notify_on_accept_);
@@ -186,8 +194,8 @@ void PosixEngineListenerImpl::AsyncConnectionAcceptor::NotifyOnAccept(
     // For UNIX sockets, the accept call might not fill up the member
     // sun_path of sockaddr_un, so explicitly call getpeername to get it.
     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) {
+      auto peer_address = posix_interface.PeerAddress(fd.value());
+      if (!peer_address.ok()) {
         auto listener_addr_uri = ResolvedAddressToURI(socket_.addr);
         LOG(ERROR) << "Failed getpeername: " << grpc_core::StrError(errno)
                    << ". Dropping the connection, and continuing "
@@ -195,17 +203,16 @@ void PosixEngineListenerImpl::AsyncConnectionAcceptor::NotifyOnAccept(
                    << (listener_addr_uri.ok() ? *listener_addr_uri
                                               : "<unknown>")
                    << ":" << socket_.port;
-        close(fd);
+        posix_interface.Close(fd.value());
         handle_->NotifyOnRead(notify_on_accept_);
         return;
       }
-      addr = EventEngine::ResolvedAddress(addr.address(), len);
+      addr = std::move(peer_address).value();
     }
 
-    PosixSocketWrapper sock(fd);
-    (void)sock.SetSocketNoSigpipeIfPossible();
-    auto result = sock.ApplySocketMutatorInOptions(
-        GRPC_FD_SERVER_CONNECTION_USAGE, listener_->options_);
+    (void)posix_interface.SetSocketNoSigpipeIfPossible(fd.value());
+    auto result = posix_interface.ApplySocketMutatorInOptions(
+        fd.value(), GRPC_FD_SERVER_CONNECTION_USAGE, listener_->options_);
     if (!result.ok()) {
       LOG(ERROR) << "Closing acceptor. Failed to apply socket mutator: "
                  << result;
@@ -226,7 +233,7 @@ void PosixEngineListenerImpl::AsyncConnectionAcceptor::NotifyOnAccept(
     }
     auto endpoint = CreatePosixEndpoint(
         /*handle=*/listener_->poller_->CreateHandle(
-            fd, *peer_name, listener_->poller_->CanTrackErrors()),
+            fd.value(), *peer_name, listener_->poller_->CanTrackErrors()),
         /*on_shutdown=*/nullptr, /*engine=*/listener_->engine_,
         // allocator=
         listener_->memory_allocator_factory_->CreateMemoryAllocator(
@@ -238,7 +245,7 @@ void PosixEngineListenerImpl::AsyncConnectionAcceptor::NotifyOnAccept(
       // Call on_accept_ and then resume accepting new connections
       // by continuing the parent for-loop.
       listener_->on_accept_(
-          /*listener_fd=*/handle_->WrappedFd(),
+          /*listener_fd=*/handle_->WrappedFd().fd(),
           /*endpoint=*/std::move(endpoint),
           /*is_external=*/false,
           /*memory_allocator=*/
@@ -260,18 +267,19 @@ absl::Status PosixEngineListenerImpl::HandleExternalConnection(
     return absl::UnknownError(
         absl::StrCat("HandleExternalConnection: Invalid peer socket: ", fd));
   }
-  PosixSocketWrapper sock(fd);
-  (void)sock.SetSocketNoSigpipeIfPossible();
-  auto peer_name = sock.PeerAddressString();
+  auto& posix_interface = poller_->posix_interface();
+  FileDescriptor wrapped = posix_interface.Adopt(fd);
+  (void)posix_interface.SetSocketNoSigpipeIfPossible(wrapped);
+  auto peer_name = posix_interface.PeerAddressString(wrapped);
   if (!peer_name.ok()) {
     return absl::UnknownError(
         absl::StrCat("HandleExternalConnection: peer not connected: ",
                      peer_name.status().ToString()));
   }
   grpc_core::EnsureRunInExecCtx([this, peer_name = std::move(*peer_name),
-                                 pending_data, listener_fd, fd]() mutable {
+                                 pending_data, listener_fd, wrapped]() mutable {
     auto endpoint = CreatePosixEndpoint(
-        /*handle=*/poller_->CreateHandle(fd, peer_name,
+        /*handle=*/poller_->CreateHandle(wrapped, peer_name,
                                          poller_->CanTrackErrors()),
         /*on_shutdown=*/nullptr, /*engine=*/engine_,
         /*allocator=*/

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

@@ -24,7 +24,6 @@
 #include <atomic>
 #include <list>
 #include <memory>
-#include <string>
 #include <utility>
 
 #include "absl/base/thread_annotations.h"
@@ -32,6 +31,7 @@
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "src/core/lib/event_engine/posix.h"
+#include "src/core/lib/event_engine/posix_engine/posix_interface.h"
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/util/sync.h"
 
@@ -85,7 +85,7 @@ class PosixEngineListenerImpl
           listener_(std::move(listener)),
           socket_(socket),
           handle_(listener_->poller_->CreateHandle(
-              socket_.sock.Fd(),
+              socket_.sock,
               *grpc_event_engine::experimental::
                   ResolvedAddressToNormalizedString(socket_.addr),
               listener_->poller_->CanTrackErrors())),
@@ -105,8 +105,10 @@ class PosixEngineListenerImpl
       }
     }
     ListenerSocketsContainer::ListenerSocket& Socket() { return socket_; }
+    FileDescriptor Fd() { return handle_->WrappedFd(); }
     ~AsyncConnectionAcceptor() {
-      auto address = socket_.sock.LocalAddress();
+      auto address = handle_->Poller()->posix_interface().LocalAddress(
+          handle_->WrappedFd());
       if (address.ok()) {
         // If uds socket, unlink it so that the corresponding file is deleted.
         UnlinkIfUnixDomainSocket(*address);
@@ -140,7 +142,7 @@ class PosixEngineListenerImpl
       acceptors_.push_back(new AsyncConnectionAcceptor(
           listener_->engine_, listener_->shared_from_this(), socket));
       if (on_append_) {
-        on_append_(socket.sock.Fd());
+        on_append_(socket.sock.fd());
       }
     }