grpc 1.73.0 → 1.74.0

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

@@ -21,13 +21,8 @@
 #include <grpc/grpc.h>
 #include <grpc/support/port_platform.h>
 
-#include <functional>
-#include <string>
 #include <utility>
 
-#include "absl/log/check.h"
-#include "absl/status/status.h"
-#include "absl/status/statusor.h"
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/lib/iomgr/socket_mutator.h"
 #include "src/core/lib/resource_quota/resource_quota.h"
@@ -148,177 +143,22 @@ struct PosixTcpOptions {
 PosixTcpOptions TcpOptionsFromEndpointConfig(
     const grpc_event_engine::experimental::EndpointConfig& config);
 
-// a wrapper for accept or accept4
-int Accept4(int sockfd,
-            grpc_event_engine::experimental::EventEngine::ResolvedAddress& addr,
-            int nonblock, int cloexec);
-
 // Unlink the path pointed to by the given address if it refers to UDS path.
 void UnlinkIfUnixDomainSocket(
     const EventEngine::ResolvedAddress& resolved_addr);
 
-class PosixSocketWrapper {
- public:
-  explicit PosixSocketWrapper(int fd) : fd_(fd) { CHECK_GT(fd_, 0); }
-
-  PosixSocketWrapper() : fd_(-1) {};
-
-  ~PosixSocketWrapper() = default;
-
-  // Instruct the kernel to wait for specified number of bytes to be received on
-  // the socket before generating an interrupt for packet receive. If the call
-  // succeeds, it returns the number of bytes (wait threshold) that was actually
-  // set.
-  absl::StatusOr<int> SetSocketRcvLowat(int bytes);
-
-  // Set socket to use zerocopy
-  absl::Status SetSocketZeroCopy();
-
-  // Set socket to non blocking mode
-  absl::Status SetSocketNonBlocking(int non_blocking);
-
-  // Set socket to close on exec
-  absl::Status SetSocketCloexec(int close_on_exec);
-
-  // Set socket to reuse old addresses
-  absl::Status SetSocketReuseAddr(int reuse);
-
-  // Disable nagle algorithm
-  absl::Status SetSocketLowLatency(int low_latency);
-
-  // Set SO_REUSEPORT
-  absl::Status SetSocketReusePort(int reuse);
-
-  // Set Differentiated Services Code Point (DSCP)
-  absl::Status SetSocketDscp(int dscp);
-
-  // Override default Tcp user timeout values if necessary.
-  void TrySetSocketTcpUserTimeout(const PosixTcpOptions& options,
-                                  bool is_client);
-
-  // Tries to set SO_NOSIGPIPE if available on this platform.
-  // If SO_NO_SIGPIPE is not available, returns not OK status.
-  absl::Status SetSocketNoSigpipeIfPossible();
-
-  // Tries to set IP_PKTINFO if available on this platform. If IP_PKTINFO is not
-  // available, returns not OK status.
-  absl::Status SetSocketIpPktInfoIfPossible();
-
-  // Tries to set IPV6_RECVPKTINFO if available on this platform. If
-  // IPV6_RECVPKTINFO is not available, returns not OK status.
-  absl::Status SetSocketIpv6RecvPktInfoIfPossible();
-
-  // Tries to set the socket's send buffer to given size.
-  absl::Status SetSocketSndBuf(int buffer_size_bytes);
-
-  // Tries to set the socket's receive buffer to given size.
-  absl::Status SetSocketRcvBuf(int buffer_size_bytes);
-
-  // Tries to set the socket using a grpc_socket_mutator
-  absl::Status SetSocketMutator(grpc_fd_usage usage,
-                                grpc_socket_mutator* mutator);
-
-  // Extracts the first socket mutator from config if any and applies on the fd.
-  absl::Status ApplySocketMutatorInOptions(grpc_fd_usage usage,
-                                           const PosixTcpOptions& options);
-
-  // Return LocalAddress as EventEngine::ResolvedAddress
-  absl::StatusOr<EventEngine::ResolvedAddress> LocalAddress();
+// Returns true if this system can create AF_INET6 sockets bound to ::1.
+// The value is probed once, and cached for the life of the process.
 
-  // Return PeerAddress as EventEngine::ResolvedAddress
-  absl::StatusOr<EventEngine::ResolvedAddress> PeerAddress();
+// This is more restrictive than checking for socket(AF_INET6) to succeed,
+// because Linux with "net.ipv6.conf.all.disable_ipv6 = 1" is able to create
+// and bind IPv6 sockets, but cannot connect to a getsockname() of [::]:port
+// without a valid loopback interface.  Rather than expose this half-broken
+// state to library users, we turn off IPv6 sockets.
+bool IsIpv6LoopbackAvailable();
 
-  // Return LocalAddress as string
-  absl::StatusOr<std::string> LocalAddressString();
-
-  // Return PeerAddress as string
-  absl::StatusOr<std::string> PeerAddressString();
-
-  // An enum to keep track of IPv4/IPv6 socket modes.
-
-  // Currently, this information is only used when a socket is first created,
-  // but in the future we may wish to store it alongside the fd.  This would let
-  // calls like sendto() know which family to use without asking the kernel
-  // first.
-  enum DSMode {
-    // Uninitialized, or a non-IP socket.
-    DSMODE_NONE,
-    // AF_INET only.
-    DSMODE_IPV4,
-    // AF_INET6 only, because IPV6_V6ONLY could not be cleared.
-    DSMODE_IPV6,
-    // AF_INET6, which also supports ::ffff-mapped IPv4 addresses.
-    DSMODE_DUALSTACK
-  };
-
-  // Returns the underlying file-descriptor.
-  int Fd() const { return fd_; }
-
-  // Static methods
-
-  // Configure default values for tcp user timeout to be used by client
-  // and server side sockets.
-  static void ConfigureDefaultTcpUserTimeout(bool enable, int timeout,
-                                             bool is_client);
-
-  // Return true if SO_REUSEPORT is supported
-  static bool IsSocketReusePortSupported();
-
-  // Returns true if this system can create AF_INET6 sockets bound to ::1.
-  // The value is probed once, and cached for the life of the process.
-
-  // This is more restrictive than checking for socket(AF_INET6) to succeed,
-  // because Linux with "net.ipv6.conf.all.disable_ipv6 = 1" is able to create
-  // and bind IPv6 sockets, but cannot connect to a getsockname() of [::]:port
-  // without a valid loopback interface.  Rather than expose this half-broken
-  // state to library users, we turn off IPv6 sockets.
-  static bool IsIpv6LoopbackAvailable();
-
-  // Creates a new socket for connecting to (or listening on) an address.
-
-  // If addr is AF_INET6, this creates an IPv6 socket first.  If that fails,
-  // and addr is within ::ffff:0.0.0.0/96, then it automatically falls back to
-  // an IPv4 socket.
-
-  // If addr is AF_INET, AF_UNIX, or anything else, then this is similar to
-  // calling socket() directly.
-
-  // Returns an PosixSocketWrapper on success, otherwise returns a not-OK
-  // absl::Status
-
-  // The dsmode output indicates which address family was actually created.
-  static absl::StatusOr<PosixSocketWrapper> CreateDualStackSocket(
-      std::function<int(int /*domain*/, int /*type*/, int /*protocol*/)>
-          socket_factory,
-      const experimental::EventEngine::ResolvedAddress& addr, int type,
-      int protocol, DSMode& dsmode);
-
-  struct PosixSocketCreateResult;
-  // Return a PosixSocketCreateResult which manages a configured, unbound,
-  // unconnected TCP client fd.
-  //  options: may contain custom tcp settings for the fd.
-  //  target_addr: the destination address.
-  //
-  // Returns: Not-OK status on error. Otherwise it returns a
-  // PosixSocketWrapper::PosixSocketCreateResult type which includes a sock
-  // of type PosixSocketWrapper and a mapped_target_addr which is
-  // target_addr mapped to an address appropriate to the type of socket FD
-  // created. For example, if target_addr is IPv4 and dual stack sockets are
-  // available, mapped_target_addr will be an IPv4-mapped IPv6 address.
-  //
-  static absl::StatusOr<PosixSocketCreateResult>
-  CreateAndPrepareTcpClientSocket(
-      const PosixTcpOptions& options,
-      const EventEngine::ResolvedAddress& target_addr);
-
- private:
-  int fd_;
-};
-
-struct PosixSocketWrapper::PosixSocketCreateResult {
-  PosixSocketWrapper sock;
-  EventEngine::ResolvedAddress mapped_target_addr;
-};
+// Return true if SO_REUSEPORT is supported
+bool IsSocketReusePortSupported();
 
 bool SetSocketDualStack(int fd);
 

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

@@ -46,7 +46,7 @@ void TimerManager::RunSomeTimers(
 // shutdown)
 bool TimerManager::WaitUntil(grpc_core::Timestamp next) {
   grpc_core::MutexLock lock(&mu_);
-  if (shutdown_) return false;
+  if (state_ != TimerManager::State::kRunning) return false;
   // If kicked_ is true at this point, it means there was a kick from the timer
   // system that the timer-manager threads here missed. We cannot trust 'next'
   // here any longer (since there might be an earlier deadline). So if kicked_
@@ -99,7 +99,7 @@ void TimerManager::TimerInit(Timer* timer, grpc_core::Timestamp deadline,
                              experimental::EventEngine::Closure* closure) {
   if (GRPC_TRACE_FLAG_ENABLED(timer)) {
     grpc_core::MutexLock lock(&mu_);
-    if (shutdown_) {
+    if (state_ != TimerManager::State::kRunning) {
       LOG(ERROR) << "WARNING: TimerManager::" << this
                  << ": scheduling Closure::" << closure
                  << " after TimerManager has been shut down.";
@@ -112,18 +112,7 @@ bool TimerManager::TimerCancel(Timer* timer) {
   return timer_list_->TimerCancel(timer);
 }
 
-void TimerManager::Shutdown() {
-  {
-    grpc_core::MutexLock lock(&mu_);
-    if (shutdown_) return;
-    GRPC_TRACE_VLOG(timer, 2) << "TimerManager::" << this << " shutting down";
-    shutdown_ = true;
-    // Wait on the main loop to exit.
-    cv_wait_.Signal();
-  }
-  main_loop_exit_signal_->WaitForNotification();
-  GRPC_TRACE_VLOG(timer, 2) << "TimerManager::" << this << " shutdown complete";
-}
+void TimerManager::Shutdown() { SuspendOrShutdown(true); }
 
 TimerManager::~TimerManager() { Shutdown(); }
 
@@ -137,16 +126,38 @@ void TimerManager::Kick() {
 
 void TimerManager::RestartPostFork() {
   grpc_core::MutexLock lock(&mu_);
-  CHECK(GPR_LIKELY(shutdown_));
+  CHECK(state_ != TimerManager::State::kRunning);
   GRPC_TRACE_VLOG(timer, 2)
-      << "TimerManager::" << this << " restarting after shutdown";
-  shutdown_ = false;
-  main_loop_exit_signal_.emplace();
-  thread_pool_->Run([this]() { MainLoop(); });
+      << "TimerManager::" << this << " restarting after suspend";
+  if (state_ == TimerManager::State::kSuspended) {
+    state_ = TimerManager::State::kRunning;
+    main_loop_exit_signal_.emplace();
+    thread_pool_->Run([this]() { MainLoop(); });
+  }
 }
 
-void TimerManager::PrepareFork() { Shutdown(); }
-void TimerManager::PostforkParent() { RestartPostFork(); }
-void TimerManager::PostforkChild() { RestartPostFork(); }
+void TimerManager::PrepareFork() { SuspendOrShutdown(false); }
+
+void TimerManager::PostFork() { RestartPostFork(); }
+
+void TimerManager::SuspendOrShutdown(bool shutdown) {
+  {
+    grpc_core::MutexLock lock(&mu_);
+    if (shutdown) {
+      // Pool will become shut down whether it was running or suspended
+      state_ = TimerManager::State::kShutdown;
+    } else if (state_ == TimerManager::State::kRunning) {
+      state_ = TimerManager::State::kSuspended;
+    }
+    GRPC_TRACE_VLOG(timer, 2) << "TimerManager::" << this
+                              << (shutdown ? " shutting down" : " suspending");
+    // Wait on the main loop to exit.
+    cv_wait_.Signal();
+  }
+  main_loop_exit_signal_->WaitForNotification();
+  GRPC_TRACE_VLOG(timer, 2)
+      << "TimerManager::" << this
+      << (shutdown ? " shutdown complete" : " suspend complete");
+}
 
 }  // namespace grpc_event_engine::experimental

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

@@ -28,7 +28,6 @@
 #include <vector>
 
 #include "absl/base/thread_annotations.h"
-#include "src/core/lib/event_engine/forkable.h"
 #include "src/core/lib/event_engine/posix_engine/timer.h"
 #include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/util/notification.h"
@@ -41,11 +40,11 @@ namespace grpc_event_engine::experimental {
 // all times, and thus effectively preventing the thundering herd problem.
 // TODO(ctiller): consider unifying this thread pool and the one in
 // thread_pool.{h,cc}.
-class TimerManager final : public grpc_event_engine::experimental::Forkable {
+class TimerManager final {
  public:
   explicit TimerManager(
       std::shared_ptr<grpc_event_engine::experimental::ThreadPool> thread_pool);
-  ~TimerManager() override;
+  ~TimerManager();
 
   grpc_core::Timestamp Now() { return host_.Now(); }
 
@@ -58,9 +57,8 @@ class TimerManager final : public grpc_event_engine::experimental::Forkable {
   // Called on destruction, prefork, and manually when needed.
   void Shutdown();
 
-  void PrepareFork() override;
-  void PostforkParent() override;
-  void PostforkChild() override;
+  void PrepareFork();
+  void PostFork();
 
  private:
   class Host final : public TimerListHost {
@@ -75,12 +73,20 @@ class TimerManager final : public grpc_event_engine::experimental::Forkable {
     TimerManager* const timer_manager_;
   };
 
+  enum class State {
+    kRunning,   // processing timers
+    kShutdown,  // Shutdown
+    kSuspended  // Temporarily suspended, e.g. on fork
+  };
+
   void RestartPostFork();
   void MainLoop();
   void RunSomeTimers(std::vector<experimental::EventEngine::Closure*> timers);
   bool WaitUntil(grpc_core::Timestamp next);
   void Kick();
 
+  void SuspendOrShutdown(bool shutdown);
+
   grpc_core::Mutex mu_;
   // Condvar associated with the main thread waiting to wakeup and work.
   // Threads wait on this until either a timeout is reached or the timer manager
@@ -89,13 +95,9 @@ class TimerManager final : public grpc_event_engine::experimental::Forkable {
   // thread.
   grpc_core::CondVar cv_wait_;
   Host host_;
-  // are we shutting down?
-  bool shutdown_ ABSL_GUARDED_BY(mu_) = false;
-  // are we shutting down?
+  State state_ ABSL_GUARDED_BY(mu_) = State::kRunning;
   bool kicked_ ABSL_GUARDED_BY(mu_) = false;
-  // number of timer wakeups
   uint64_t wakeups_ ABSL_GUARDED_BY(mu_) = false;
-  // actual timer implementation
   std::unique_ptr<TimerList> timer_list_;
   std::shared_ptr<grpc_event_engine::experimental::ThreadPool> thread_pool_;
   std::optional<grpc_core::Notification> main_loop_exit_signal_;