grpc 1.53.0.pre2 → 1.54.0

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

@@ -17,17 +17,12 @@
 #include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
 
+#include "src/core/lib/config/config_vars.h"
 #include "src/core/lib/event_engine/posix_engine/ev_epoll1_linux.h"
 #include "src/core/lib/event_engine/posix_engine/ev_poll_posix.h"
 #include "src/core/lib/event_engine/posix_engine/event_poller.h"
-#include "src/core/lib/gprpp/global_config.h"
-#include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/iomgr/port.h"
 
-#ifdef GRPC_POSIX_SOCKET_TCP
-GPR_GLOBAL_CONFIG_DECLARE_STRING(grpc_poll_strategy);
-#endif
-
 namespace grpc_event_engine {
 namespace experimental {
 
@@ -41,10 +36,9 @@ bool PollStrategyMatches(absl::string_view strategy, absl::string_view want) {
 }  // namespace
 
 PosixEventPoller* MakeDefaultPoller(Scheduler* scheduler) {
-  static const char* poll_strategy =
-      GPR_GLOBAL_CONFIG_GET(grpc_poll_strategy).release();
   PosixEventPoller* poller = nullptr;
-  auto strings = absl::StrSplit(poll_strategy, ',');
+  auto strings =
+      absl::StrSplit(grpc_core::ConfigVars::Get().PollStrategy(), ',');
   for (auto it = strings.begin(); it != strings.end() && poller == nullptr;
        it++) {
     if (PollStrategyMatches(*it, "epoll1")) {

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

@@ -575,12 +575,11 @@ void PosixEndpointImpl::HandleRead(absl::Status status) {
   Unref();
 }
 
-void PosixEndpointImpl::Read(absl::AnyInvocable<void(absl::Status)> on_read,
+bool PosixEndpointImpl::Read(absl::AnyInvocable<void(absl::Status)> on_read,
                              SliceBuffer* buffer,
                              const EventEngine::Endpoint::ReadArgs* args) {
   grpc_core::ReleasableMutexLock lock(&read_mu_);
   GPR_ASSERT(read_cb_ == nullptr);
-  read_cb_ = std::move(on_read);
   incoming_buffer_ = buffer;
   incoming_buffer_->Clear();
   incoming_buffer_->Swap(last_read_buffer_);
@@ -591,6 +590,7 @@ void PosixEndpointImpl::Read(absl::AnyInvocable<void(absl::Status)> on_read,
   }
   Ref().release();
   if (is_first_read_) {
+    read_cb_ = std::move(on_read);
     UpdateRcvLowat();
     // Endpoint read called for the very first time. Register read callback
     // with the polling engine.
@@ -598,16 +598,40 @@ void PosixEndpointImpl::Read(absl::AnyInvocable<void(absl::Status)> on_read,
     lock.Release();
     handle_->NotifyOnRead(on_read_);
   } else if (inq_ == 0) {
+    read_cb_ = std::move(on_read);
     UpdateRcvLowat();
     lock.Release();
     // Upper layer asked to read more but we know there is no pending data to
     // read from previous reads. So, wait for POLLIN.
     handle_->NotifyOnRead(on_read_);
   } else {
-    lock.Release();
-    on_read_->SetStatus(absl::OkStatus());
-    engine_->Run(on_read_);
+    absl::Status status;
+    MaybeMakeReadSlices();
+    if (!TcpDoRead(status)) {
+      UpdateRcvLowat();
+      read_cb_ = std::move(on_read);
+      // We've consumed the edge, request a new one.
+      lock.Release();
+      handle_->NotifyOnRead(on_read_);
+      return false;
+    }
+    if (!status.ok()) {
+      // Read failed immediately. Schedule the on_read callback to run
+      // asynchronously.
+      lock.Release();
+      engine_->Run([on_read = std::move(on_read), status]() mutable {
+        on_read(status);
+      });
+      Unref();
+      return false;
+    }
+    // Read succeeded immediately. Return true and don't run the on_read
+    // callback.
+    incoming_buffer_ = nullptr;
+    Unref();
+    return true;
   }
+  return false;
 }
 
 #ifdef GRPC_LINUX_ERRQUEUE
@@ -937,7 +961,7 @@ bool PosixEndpointImpl::DoFlushZerocopy(TcpZerocopySendRecord* record,
       } else {
 #ifdef GRPC_LINUX_ERRQUEUE
         GRPC_LOG_EVERY_N_SEC(
-            1,
+            1, GPR_INFO,
             "Tx0cp encountered an ENOBUFS error possibly because one or "
             "both of RLIMIT_MEMLOCK or hard memlock ulimit values are too "
             "small for the intended user. Current system value of "
@@ -1103,7 +1127,7 @@ void PosixEndpointImpl::HandleWrite(absl::Status status) {
   }
 }
 
-void PosixEndpointImpl::Write(
+bool PosixEndpointImpl::Write(
     absl::AnyInvocable<void(absl::Status)> on_writable, SliceBuffer* data,
     const EventEngine::Endpoint::WriteArgs* args) {
   absl::Status status = absl::OkStatus();
@@ -1114,11 +1138,15 @@ void PosixEndpointImpl::Write(
   GPR_DEBUG_ASSERT(data != nullptr);
 
   if (data->Length() == 0) {
-    on_writable(handle_->IsHandleShutdown()
-                    ? TcpAnnotateError(absl::InternalError("EOF"))
-                    : status);
     TcpShutdownTracedBufferList();
-    return;
+    if (handle_->IsHandleShutdown()) {
+      status = TcpAnnotateError(absl::InternalError("EOF"));
+      engine_->Run([on_writable = std::move(on_writable), status]() mutable {
+        on_writable(status);
+      });
+      return false;
+    }
+    return true;
   }
 
   zerocopy_send_record = TcpGetSendZerocopyRecord(*data);
@@ -1142,14 +1170,19 @@ void PosixEndpointImpl::Write(
     write_cb_ = std::move(on_writable);
     current_zerocopy_send_ = zerocopy_send_record;
     handle_->NotifyOnWrite(on_write_);
-  } else {
-    // TODO(vigneshbabu): Consider eventually running this callback inline to
-    // avoid a thread hop. At the time of submission, it causes deadlocks which
-    // should be reolved after ExecCtx removal.
+    return false;
+  }
+  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);
     });
+    return false;
   }
+  // Write succeeded immediately. Return true and don't run the on_writable
+  // callback.
+  return true;
 }
 
 void PosixEndpointImpl::MaybeShutdown(

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

@@ -472,12 +472,12 @@ class PosixEndpointImpl : public grpc_core::RefCounted<PosixEndpointImpl> {
       grpc_event_engine::experimental::MemoryAllocator&& allocator,
       const PosixTcpOptions& options);
   ~PosixEndpointImpl() override;
-  void Read(
+  bool Read(
       absl::AnyInvocable<void(absl::Status)> on_read,
       grpc_event_engine::experimental::SliceBuffer* buffer,
       const grpc_event_engine::experimental::EventEngine::Endpoint::ReadArgs*
           args);
-  void Write(
+  bool Write(
       absl::AnyInvocable<void(absl::Status)> on_writable,
       grpc_event_engine::experimental::SliceBuffer* data,
       const grpc_event_engine::experimental::EventEngine::Endpoint::WriteArgs*
@@ -608,20 +608,20 @@ class PosixEndpoint : public PosixEndpointWithFdSupport {
       : impl_(new PosixEndpointImpl(handle, on_shutdown, std::move(engine),
                                     std::move(allocator), options)) {}
 
-  void Read(
+  bool Read(
       absl::AnyInvocable<void(absl::Status)> on_read,
       grpc_event_engine::experimental::SliceBuffer* buffer,
       const grpc_event_engine::experimental::EventEngine::Endpoint::ReadArgs*
           args) override {
-    impl_->Read(std::move(on_read), buffer, args);
+    return impl_->Read(std::move(on_read), buffer, args);
   }
 
-  void Write(
+  bool Write(
       absl::AnyInvocable<void(absl::Status)> on_writable,
       grpc_event_engine::experimental::SliceBuffer* data,
       const grpc_event_engine::experimental::EventEngine::Endpoint::WriteArgs*
           args) override {
-    impl_->Write(std::move(on_writable), data, args);
+    return impl_->Write(std::move(on_writable), data, args);
   }
 
   const grpc_event_engine::experimental::EventEngine::ResolvedAddress&
@@ -661,14 +661,14 @@ class PosixEndpoint : public PosixEndpointWithFdSupport {
  public:
   PosixEndpoint() = default;
 
-  void Read(absl::AnyInvocable<void(absl::Status)> /*on_read*/,
+  bool Read(absl::AnyInvocable<void(absl::Status)> /*on_read*/,
             grpc_event_engine::experimental::SliceBuffer* /*buffer*/,
             const grpc_event_engine::experimental::EventEngine::Endpoint::
                 ReadArgs* /*args*/) override {
     grpc_core::Crash("PosixEndpoint::Read not supported on this platform");
   }
 
-  void Write(absl::AnyInvocable<void(absl::Status)> /*on_writable*/,
+  bool Write(absl::AnyInvocable<void(absl::Status)> /*on_writable*/,
              grpc_event_engine::experimental::SliceBuffer* /*data*/,
              const grpc_event_engine::experimental::EventEngine::Endpoint::
                  WriteArgs* /*args*/) override {

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

@@ -232,7 +232,7 @@ EventEngine::ConnectionHandle PosixEventEngine::ConnectInternal(
          ep = absl::FailedPreconditionError(absl::StrCat(
              "connect failed: ", "invalid addr: ",
              addr_uri.value()))]() mutable { on_connect(std::move(ep)); });
-    return EventEngine::kInvalidConnectionHandle;
+    return EventEngine::ConnectionHandle::kInvalid;
   }
 
   std::string name = absl::StrCat("tcp-client:", addr_uri.value());
@@ -253,7 +253,7 @@ EventEngine::ConnectionHandle PosixEventEngine::ConnectInternal(
                                   std::move(allocator), options)]() mutable {
       on_connect(std::move(ep));
     });
-    return EventEngine::kInvalidConnectionHandle;
+    return EventEngine::ConnectionHandle::kInvalid;
   }
   if (saved_errno != EWOULDBLOCK && saved_errno != EINPROGRESS) {
     // Connection already failed. Return 0 to discourage any cancellation
@@ -265,7 +265,7 @@ EventEngine::ConnectionHandle PosixEventEngine::ConnectInternal(
                           " error: ", std::strerror(saved_errno)))]() mutable {
       on_connect(std::move(ep));
     });
-    return EventEngine::kInvalidConnectionHandle;
+    return EventEngine::ConnectionHandle::kInvalid;
   }
   AsyncConnect* ac = new AsyncConnect(
       std::move(on_connect), shared_from_this(), executor_.get(), handle,
@@ -299,7 +299,8 @@ PosixEnginePollerManager::PosixEnginePollerManager(
 PosixEnginePollerManager::PosixEnginePollerManager(PosixEventPoller* poller)
     : poller_(poller),
       poller_state_(PollerState::kExternal),
-      executor_(nullptr) {
+      executor_(nullptr),
+      trigger_shutdown_called_(false) {
   GPR_DEBUG_ASSERT(poller_ != nullptr);
 }
 
@@ -559,7 +560,7 @@ EventEngine::ConnectionHandle PosixEventEngine::Connect(
   if (!socket.ok()) {
     Run([on_connect = std::move(on_connect),
          status = socket.status()]() mutable { on_connect(status); });
-    return EventEngine::kInvalidConnectionHandle;
+    return EventEngine::ConnectionHandle::kInvalid;
   }
   return ConnectInternal((*socket).sock, std::move(on_connect),
                          (*socket).mapped_target_addr,

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

@@ -64,11 +64,14 @@ PosixEngineListenerImpl::PosixEngineListenerImpl(
 absl::StatusOr<int> PosixEngineListenerImpl::Bind(
     const EventEngine::ResolvedAddress& addr,
     PosixListenerWithFdSupport::OnPosixBindNewFdCallback on_bind_new_fd) {
+  absl::MutexLock lock(&this->mu_);
+  if (this->started_) {
+    return absl::FailedPreconditionError(
+        "Listener is already started, ports can no longer be bound");
+  }
   EventEngine::ResolvedAddress res_addr = addr;
   EventEngine::ResolvedAddress addr6_v4mapped;
   int requested_port = ResolvedAddressGetPort(res_addr);
-  absl::MutexLock lock(&this->mu_);
-  GPR_ASSERT(!this->started_);
   GPR_ASSERT(addr.size() <= EventEngine::ResolvedAddress::MAX_SIZE_BYTES);
   UnlinkIfUnixDomainSocket(addr);
 
@@ -279,7 +282,7 @@ PosixEngineListenerImpl::~PosixEngineListenerImpl() {
   // been destroyed. This is because each AsyncConnectionAcceptor has a
   // shared_ptr ref to the parent PosixEngineListenerImpl.
   if (on_shutdown_ != nullptr) {
-    on_shutdown_(absl::InternalError("Shutting down listener"));
+    on_shutdown_(absl::OkStatus());
   }
 }
 

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

@@ -30,6 +30,7 @@
 
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/crash.h"  // IWYU pragma: keep
+#include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_POSIX_SOCKET_UTILS_COMMON
@@ -96,8 +97,21 @@ absl::Status ErrorForFd(
 
 int CreateSocket(std::function<int(int, int, int)> socket_factory, int family,
                  int type, int protocol) {
-  return socket_factory != nullptr ? socket_factory(family, type, protocol)
-                                   : socket(family, type, protocol);
+  int res = socket_factory != nullptr ? socket_factory(family, type, protocol)
+                                      : socket(family, type, protocol);
+  if (res < 0 && errno == EMFILE) {
+    int saved_errno = errno;
+    GRPC_LOG_EVERY_N_SEC(
+        10, GPR_ERROR,
+        "socket(%d, %d, %d) returned %d with error: |%s|. This process "
+        "might not have a sufficient file descriptor limit for the number "
+        "of connections grpc wants to open (which is generally a function of "
+        "the number of grpc channels, the lb policy of each channel, and the "
+        "number of backends each channel is load balancing across).",
+        family, type, protocol, res, grpc_core::StrError(errno).c_str());
+    errno = saved_errno;
+  }
+  return res;
 }
 
 absl::Status PrepareTcpClientSocket(PosixSocketWrapper sock,
@@ -126,6 +140,11 @@ absl::Status PrepareTcpClientSocket(PosixSocketWrapper sock,
   return absl::OkStatus();
 }
 
+bool SetSocketDualStack(int fd) {
+  const int off = 0;
+  return 0 == setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &off, sizeof(off));
+}
+
 #endif  // GRPC_POSIX_SOCKET_UTILS_COMMON
 
 }  // namespace
@@ -606,11 +625,6 @@ absl::Status PosixSocketWrapper::ApplySocketMutatorInOptions(
   return SetSocketMutator(usage, options.socket_mutator);
 }
 
-bool PosixSocketWrapper::SetSocketDualStack() {
-  const int off = 0;
-  return 0 == setsockopt(fd_, IPPROTO_IPV6, IPV6_V6ONLY, &off, sizeof(off));
-}
-
 bool PosixSocketWrapper::IsIpv6LoopbackAvailable() {
   static bool kIpv6LoopbackAvailable = []() -> bool {
     int fd = socket(AF_INET6, SOCK_STREAM, 0);
@@ -686,19 +700,18 @@ absl::StatusOr<PosixSocketWrapper> PosixSocketWrapper::CreateDualStackSocket(
       newfd = -1;
       errno = EAFNOSUPPORT;
     }
-    if (newfd < 0) {
-      return ErrorForFd(newfd, addr);
-    }
-    PosixSocketWrapper sock(newfd);
     // Check if we've got a valid dualstack socket.
-    if (sock.SetSocketDualStack()) {
+    if (newfd > 0 && SetSocketDualStack(newfd)) {
       dsmode = PosixSocketWrapper::DSMode::DSMODE_DUALSTACK;
-      return sock;
+      return PosixSocketWrapper(newfd);
     }
     // If this isn't an IPv4 address, then return whatever we've got.
     if (!ResolvedAddressIsV4Mapped(addr, nullptr)) {
+      if (newfd <= 0) {
+        return ErrorForFd(newfd, addr);
+      }
       dsmode = PosixSocketWrapper::DSMode::DSMODE_IPV6;
-      return sock;
+      return PosixSocketWrapper(newfd);
     }
     // Fall back to AF_INET.
     if (newfd >= 0) {
@@ -820,10 +833,6 @@ absl::Status PosixSocketWrapper::ApplySocketMutatorInOptions(
   grpc_core::Crash("unimplemented");
 }
 
-bool PosixSocketWrapper::SetSocketDualStack() {
-  grpc_core::Crash("unimplemented");
-}
-
 bool PosixSocketWrapper::IsSocketReusePortSupported() {
   grpc_core::Crash("unimplemented");
 }

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

@@ -238,9 +238,6 @@ class PosixSocketWrapper {
     DSMODE_DUALSTACK
   };
 
-  // Tries to set the socket to dualstack. Returns true on success.
-  bool SetSocketDualStack();
-
   // Returns the underlying file-descriptor.
   int Fd() const { return fd_; }
 

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

@@ -31,7 +31,8 @@ namespace experimental {
 EventEngine::ResolvedAddress::ResolvedAddress(const sockaddr* address,
                                               socklen_t size)
     : size_(size) {
-  GPR_ASSERT(size <= sizeof(address_));
+  GPR_DEBUG_ASSERT(size >= 0);
+  GPR_ASSERT(static_cast<size_t>(size) <= sizeof(address_));
   memcpy(&address_, address, size);
 }
 

data/src/core/lib/event_engine/windows/win_socket.cc

@@ -58,7 +58,6 @@ void WinSocket::Shutdown() {
                                      this);
     return;
   }
-  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WinSocket::%p shutting down now.", this);
   // Grab the function pointer for DisconnectEx for that specific socket.
   // It may change depending on the interface.
   GUID guid = WSAID_DISCONNECTEX;