grpc 1.53.2 → 1.54.0

data/src/core/lib/iomgr/ev_posix.h

@@ -24,14 +24,11 @@
 #include <poll.h>
 
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gprpp/global_config.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/pollset.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/iomgr/wakeup_fd_posix.h"
 
-GPR_GLOBAL_CONFIG_DECLARE_STRING(grpc_poll_strategy);
-
 extern grpc_core::DebugOnlyTraceFlag grpc_fd_trace;       // Disabled by default
 extern grpc_core::DebugOnlyTraceFlag grpc_polling_trace;  // Disabled by default
 

data/src/core/lib/iomgr/event_engine_shims/endpoint.cc

@@ -33,6 +33,8 @@
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
 #include "src/core/lib/event_engine/trace.h"
 #include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gprpp/construct_destruct.h"
+#include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/endpoint.h"
@@ -94,15 +96,101 @@ class EventEngineEndpointWrapper {
   grpc_endpoint* GetGrpcEndpoint() { return &eeep_->base; }
 
   // Read using the underlying EventEngine endpoint object.
-  void Read(absl::AnyInvocable<void(absl::Status)> on_read, SliceBuffer* buffer,
+  bool Read(grpc_closure* read_cb, grpc_slice_buffer* pending_read_buffer,
             const EventEngine::Endpoint::ReadArgs* args) {
-    endpoint_->Read(std::move(on_read), buffer, args);
+    Ref();
+    pending_read_cb_ = read_cb;
+    pending_read_buffer_ = pending_read_buffer;
+    // TODO(vigneshbabu): Use SliceBufferCast<> here.
+    grpc_core::Construct(reinterpret_cast<SliceBuffer*>(&eeep_->read_buffer),
+                         SliceBuffer::TakeCSliceBuffer(*pending_read_buffer_));
+    SliceBuffer* read_buffer =
+        reinterpret_cast<SliceBuffer*>(&eeep_->read_buffer);
+    read_buffer->Clear();
+    return endpoint_->Read(
+        [this](absl::Status status) { FinishPendingRead(status); }, read_buffer,
+        args);
+  }
+
+  void FinishPendingRead(absl::Status status) {
+    auto* read_buffer = reinterpret_cast<SliceBuffer*>(&eeep_->read_buffer);
+    grpc_slice_buffer_move_into(read_buffer->c_slice_buffer(),
+                                pending_read_buffer_);
+    read_buffer->~SliceBuffer();
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
+      size_t i;
+      gpr_log(GPR_INFO, "TCP: %p READ (peer=%s) error=%s", eeep_->wrapper,
+              std::string(eeep_->wrapper->PeerAddress()).c_str(),
+              status.ToString().c_str());
+      if (gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
+        for (i = 0; i < pending_read_buffer_->count; i++) {
+          char* dump = grpc_dump_slice(pending_read_buffer_->slices[i],
+                                       GPR_DUMP_HEX | GPR_DUMP_ASCII);
+          gpr_log(GPR_DEBUG, "READ DATA: %s", dump);
+          gpr_free(dump);
+        }
+      }
+    }
+    pending_read_buffer_ = nullptr;
+    grpc_closure* cb = pending_read_cb_;
+    pending_read_cb_ = nullptr;
+    if (grpc_core::ExecCtx::Get() == nullptr) {
+      grpc_core::ApplicationCallbackExecCtx app_ctx;
+      grpc_core::ExecCtx exec_ctx;
+      grpc_core::ExecCtx::Run(DEBUG_LOCATION, cb, status);
+    } else {
+      grpc_core::Closure::Run(DEBUG_LOCATION, cb, status);
+    }
+    // For the ref taken in EventEngineEndpointWrapper::Read().
+    Unref();
   }
 
   // Write using the underlying EventEngine endpoint object
-  void Write(absl::AnyInvocable<void(absl::Status)> on_writable,
-             SliceBuffer* data, const EventEngine::Endpoint::WriteArgs* args) {
-    endpoint_->Write(std::move(on_writable), data, args);
+  bool Write(grpc_closure* write_cb, grpc_slice_buffer* slices,
+             const EventEngine::Endpoint::WriteArgs* args) {
+    Ref();
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
+      size_t i;
+      gpr_log(GPR_INFO, "TCP: %p WRITE (peer=%s)", this,
+              std::string(PeerAddress()).c_str());
+      if (gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
+        for (i = 0; i < slices->count; i++) {
+          char* dump =
+              grpc_dump_slice(slices->slices[i], GPR_DUMP_HEX | GPR_DUMP_ASCII);
+          gpr_log(GPR_DEBUG, "WRITE DATA: %s", dump);
+          gpr_free(dump);
+        }
+      }
+    }
+    // TODO(vigneshbabu): Use SliceBufferCast<> here.
+    grpc_core::Construct(reinterpret_cast<SliceBuffer*>(&eeep_->write_buffer),
+                         SliceBuffer::TakeCSliceBuffer(*slices));
+    SliceBuffer* write_buffer =
+        reinterpret_cast<SliceBuffer*>(&eeep_->write_buffer);
+    pending_write_cb_ = write_cb;
+    return endpoint_->Write(
+        [this](absl::Status status) { FinishPendingWrite(status); },
+        write_buffer, args);
+  }
+
+  void FinishPendingWrite(absl::Status status) {
+    auto* write_buffer = reinterpret_cast<SliceBuffer*>(&eeep_->write_buffer);
+    write_buffer->~SliceBuffer();
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
+      gpr_log(GPR_INFO, "TCP: %p WRITE (peer=%s) error=%s", this,
+              std::string(PeerAddress()).c_str(), status.ToString().c_str());
+    }
+    grpc_closure* cb = pending_write_cb_;
+    pending_write_cb_ = nullptr;
+    if (grpc_core::ExecCtx::Get() == nullptr) {
+      grpc_core::ApplicationCallbackExecCtx app_ctx;
+      grpc_core::ExecCtx exec_ctx;
+      grpc_core::ExecCtx::Run(DEBUG_LOCATION, cb, status);
+    } else {
+      grpc_core::Closure::Run(DEBUG_LOCATION, cb, status);
+    }
+    // For the ref taken in EventEngineEndpointWrapper::Write().
+    Unref();
   }
 
   // Returns true if the endpoint is not yet shutdown. In that case, it also
@@ -186,6 +274,9 @@ class EventEngineEndpointWrapper {
   std::atomic<int64_t> shutdown_ref_{1};
   absl::AnyInvocable<void(absl::StatusOr<int>)> on_release_fd_;
   grpc_core::Mutex mu_;
+  grpc_closure* pending_read_cb_;
+  grpc_closure* pending_write_cb_;
+  grpc_slice_buffer* pending_read_buffer_;
   std::string peer_address_;
   std::string local_address_;
   int fd_{-1};
@@ -204,41 +295,11 @@ void EndpointRead(grpc_endpoint* ep, grpc_slice_buffer* slices,
     return;
   }
 
-  eeep->wrapper->Ref();
   EventEngine::Endpoint::ReadArgs read_args = {min_progress_size};
-
-  // TODO(vigneshbabu): Use SliceBufferCast<> here.
-  SliceBuffer* read_buffer = new (&eeep->read_buffer)
-      SliceBuffer(SliceBuffer::TakeCSliceBuffer(*slices));
-  read_buffer->Clear();
-  eeep->wrapper->Read(
-      [eeep, cb, slices](absl::Status status) {
-        auto* read_buffer = reinterpret_cast<SliceBuffer*>(&eeep->read_buffer);
-        grpc_slice_buffer_move_into(read_buffer->c_slice_buffer(), slices);
-        read_buffer->~SliceBuffer();
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
-          size_t i;
-          gpr_log(GPR_INFO, "TCP: %p READ (peer=%s) error=%s", eeep->wrapper,
-                  std::string(eeep->wrapper->PeerAddress()).c_str(),
-                  status.ToString().c_str());
-          if (gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
-            for (i = 0; i < slices->count; i++) {
-              char* dump = grpc_dump_slice(slices->slices[i],
-                                           GPR_DUMP_HEX | GPR_DUMP_ASCII);
-              gpr_log(GPR_DEBUG, "READ DATA: %s", dump);
-              gpr_free(dump);
-            }
-          }
-        }
-        {
-          grpc_core::ApplicationCallbackExecCtx app_ctx;
-          grpc_core::ExecCtx exec_ctx;
-          grpc_core::ExecCtx::Run(DEBUG_LOCATION, cb, status);
-        }
-        // For the ref taken in EndpointRead
-        eeep->wrapper->Unref();
-      },
-      read_buffer, &read_args);
+  if (eeep->wrapper->Read(cb, slices, &read_args)) {
+    // Read succeeded immediately. Run the callback inline.
+    eeep->wrapper->FinishPendingRead(absl::OkStatus());
+  }
 
   eeep->wrapper->ShutdownUnref();
 }
@@ -256,45 +317,11 @@ void EndpointWrite(grpc_endpoint* ep, grpc_slice_buffer* slices,
     return;
   }
 
-  eeep->wrapper->Ref();
   EventEngine::Endpoint::WriteArgs write_args = {arg, max_frame_size};
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
-    size_t i;
-    gpr_log(GPR_INFO, "TCP: %p WRITE (peer=%s)", eeep->wrapper,
-            std::string(eeep->wrapper->PeerAddress()).c_str());
-    if (gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
-      for (i = 0; i < slices->count; i++) {
-        char* dump =
-            grpc_dump_slice(slices->slices[i], GPR_DUMP_HEX | GPR_DUMP_ASCII);
-        gpr_log(GPR_DEBUG, "WRITE DATA: %s", dump);
-        gpr_free(dump);
-      }
-    }
+  if (eeep->wrapper->Write(cb, slices, &write_args)) {
+    // Write succeeded immediately. Run the callback inline.
+    eeep->wrapper->FinishPendingWrite(absl::OkStatus());
   }
-
-  // TODO(vigneshbabu): Use SliceBufferCast<> here.
-  SliceBuffer* write_buffer = new (&eeep->write_buffer)
-      SliceBuffer(SliceBuffer::TakeCSliceBuffer(*slices));
-  eeep->wrapper->Write(
-      [eeep, cb](absl::Status status) {
-        auto* write_buffer =
-            reinterpret_cast<SliceBuffer*>(&eeep->write_buffer);
-        write_buffer->~SliceBuffer();
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
-          gpr_log(GPR_INFO, "TCP: %p WRITE (peer=%s) error=%s", eeep->wrapper,
-                  std::string(eeep->wrapper->PeerAddress()).c_str(),
-                  status.ToString().c_str());
-        }
-        {
-          grpc_core::ApplicationCallbackExecCtx app_ctx;
-          grpc_core::ExecCtx exec_ctx;
-          grpc_core::ExecCtx::Run(DEBUG_LOCATION, cb, status);
-        }
-        // For the ref taken in EndpointWrite
-        eeep->wrapper->Unref();
-      },
-      write_buffer, &write_args);
-
   eeep->wrapper->ShutdownUnref();
 }
 

data/src/core/lib/iomgr/iomgr.cc

@@ -29,10 +29,10 @@
 #include <grpc/support/string_util.h>
 #include <grpc/support/sync.h>
 
+#include "src/core/lib/config/config_vars.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/crash.h"
-#include "src/core/lib/gprpp/global_config.h"
 #include "src/core/lib/gprpp/thd.h"
 #include "src/core/lib/iomgr/buffer_list.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
@@ -42,15 +42,10 @@
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/iomgr/timer_manager.h"
 
-GPR_GLOBAL_CONFIG_DEFINE_BOOL(grpc_abort_on_leaks, false,
-                              "A debugging aid to cause a call to abort() when "
-                              "gRPC objects are leaked past grpc_shutdown()");
-
 static gpr_mu g_mu;
 static gpr_cv g_rcv;
 static int g_shutdown;
 static grpc_iomgr_object g_root_object;
-static bool g_grpc_abort_on_leaks;
 
 void grpc_iomgr_init() {
   grpc_core::ExecCtx exec_ctx;
@@ -65,7 +60,6 @@ void grpc_iomgr_init() {
   g_root_object.name = const_cast<char*>("root");
   grpc_iomgr_platform_init();
   grpc_timer_list_init();
-  g_grpc_abort_on_leaks = GPR_GLOBAL_CONFIG_GET(grpc_abort_on_leaks);
 }
 
 void grpc_iomgr_start() { grpc_timer_manager_init(); }
@@ -198,4 +192,6 @@ void grpc_iomgr_unregister_object(grpc_iomgr_object* obj) {
   gpr_free(obj->name);
 }
 
-bool grpc_iomgr_abort_on_leaks(void) { return g_grpc_abort_on_leaks; }
+bool grpc_iomgr_abort_on_leaks(void) {
+  return grpc_core::ConfigVars::Get().AbortOnLeaks();
+}

data/src/core/lib/iomgr/iomgr_windows.cc

@@ -24,6 +24,7 @@
 
 #include <grpc/support/log.h>
 
+#include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/iomgr/iocp_windows.h"
 #include "src/core/lib/iomgr/iomgr.h"
@@ -37,6 +38,7 @@
 #include "src/core/lib/iomgr/timer.h"
 
 extern grpc_tcp_server_vtable grpc_windows_tcp_server_vtable;
+extern grpc_tcp_server_vtable grpc_windows_event_engine_tcp_server_vtable;
 extern grpc_tcp_client_vtable grpc_windows_tcp_client_vtable;
 extern grpc_timer_vtable grpc_generic_timer_vtable;
 extern grpc_pollset_vtable grpc_windows_pollset_vtable;
@@ -81,7 +83,7 @@ static bool iomgr_platform_is_any_background_poller_thread(void) {
 }
 
 static bool iomgr_platform_add_closure_to_background_poller(
-    grpc_closure* closure, grpc_error_handle error) {
+    grpc_closure* /* closure */, grpc_error_handle /* error */) {
   return false;
 }
 
@@ -95,7 +97,11 @@ static grpc_iomgr_platform_vtable vtable = {
 
 void grpc_set_default_iomgr_platform() {
   grpc_set_tcp_client_impl(&grpc_windows_tcp_client_vtable);
-  grpc_set_tcp_server_impl(&grpc_windows_tcp_server_vtable);
+  if (grpc_core::IsEventEngineListenerEnabled()) {
+    grpc_set_tcp_server_impl(&grpc_windows_event_engine_tcp_server_vtable);
+  } else {
+    grpc_set_tcp_server_impl(&grpc_windows_tcp_server_vtable);
+  }
   grpc_set_timer_impl(&grpc_generic_timer_vtable);
   grpc_set_pollset_vtable(&grpc_windows_pollset_vtable);
   grpc_set_pollset_set_vtable(&grpc_windows_pollset_set_vtable);

data/src/core/lib/iomgr/pollset_set_windows.cc

@@ -30,19 +30,19 @@ static grpc_pollset_set* pollset_set_create(void) {
   return (grpc_pollset_set*)((intptr_t)0xdeafbeef);
 }
 
-static void pollset_set_destroy(grpc_pollset_set* pollset_set) {}
+static void pollset_set_destroy(grpc_pollset_set* /* pollset_set */) {}
 
-static void pollset_set_add_pollset(grpc_pollset_set* pollset_set,
-                                    grpc_pollset* pollset) {}
+static void pollset_set_add_pollset(grpc_pollset_set* /* pollset_set */,
+                                    grpc_pollset* /* pollset */) {}
 
-static void pollset_set_del_pollset(grpc_pollset_set* pollset_set,
-                                    grpc_pollset* pollset) {}
+static void pollset_set_del_pollset(grpc_pollset_set* /* pollset_set */,
+                                    grpc_pollset* /* pollset */) {}
 
-static void pollset_set_add_pollset_set(grpc_pollset_set* bag,
-                                        grpc_pollset_set* item) {}
+static void pollset_set_add_pollset_set(grpc_pollset_set* /* bag */,
+                                        grpc_pollset_set* /* item */) {}
 
-static void pollset_set_del_pollset_set(grpc_pollset_set* bag,
-                                        grpc_pollset_set* item) {}
+static void pollset_set_del_pollset_set(grpc_pollset_set* /* bag */,
+                                        grpc_pollset_set* /* item */) {}
 
 grpc_pollset_set_vtable grpc_windows_pollset_set_vtable = {
     pollset_set_create,          pollset_set_destroy,

data/src/core/lib/iomgr/pollset_windows.cc

@@ -105,7 +105,7 @@ static void pollset_shutdown(grpc_pollset* pollset, grpc_closure* closure) {
   }
 }
 
-static void pollset_destroy(grpc_pollset* pollset) {}
+static void pollset_destroy(grpc_pollset* /* pollset */) {}
 
 static grpc_error_handle pollset_work(grpc_pollset* pollset,
                                       grpc_pollset_worker** worker_hdl,

data/src/core/lib/iomgr/socket_utils_common_posix.cc

@@ -437,9 +437,22 @@ grpc_error_handle grpc_create_dualstack_socket(
 
 static int create_socket(grpc_socket_factory* factory, int domain, int type,
                          int protocol) {
-  return (factory != nullptr)
-             ? grpc_socket_factory_socket(factory, domain, type, protocol)
-             : socket(domain, type, protocol);
+  int res = (factory != nullptr)
+                ? grpc_socket_factory_socket(factory, domain, type, protocol)
+                : socket(domain, 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).",
+        domain, type, protocol, res, grpc_core::StrError(errno).c_str());
+    errno = saved_errno;
+  }
+  return res;
 }
 
 grpc_error_handle grpc_create_dualstack_socket_using_factory(

data/src/core/lib/iomgr/tcp_client_windows.cc

@@ -69,7 +69,7 @@ static void async_connect_unlock_and_cleanup(async_connect* ac,
   if (socket != NULL) grpc_winsocket_destroy(socket);
 }
 
-static void on_alarm(void* acp, grpc_error_handle error) {
+static void on_alarm(void* acp, grpc_error_handle /* error */) {
   async_connect* ac = (async_connect*)acp;
   gpr_mu_lock(&ac->mu);
   grpc_winsocket* socket = ac->socket;
@@ -124,7 +124,7 @@ static void on_connect(void* acp, grpc_error_handle error) {
 // Tries to issue one async connection, then schedules both an IOCP
 // notification request for the connection, and one timeout alert.
 static int64_t tcp_connect(grpc_closure* on_done, grpc_endpoint** endpoint,
-                           grpc_pollset_set* interested_parties,
+                           grpc_pollset_set* /* interested_parties */,
                            const EndpointConfig& config,
                            const grpc_resolved_address* addr,
                            grpc_core::Timestamp deadline) {

data/src/core/lib/iomgr/tcp_posix.cc

@@ -20,7 +20,6 @@
 
 #include <grpc/impl/grpc_types.h>
 
-#include "src/core/lib/gprpp/global_config_generic.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/port.h"
 

data/src/core/lib/iomgr/tcp_server_posix.cc

@@ -16,17 +16,13 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
-#include <utility>
-
-#include <grpc/support/atm.h>
-
 // FIXME: "posix" files shouldn't be depending on _GNU_SOURCE
 #ifndef _GNU_SOURCE
 #define _GNU_SOURCE
 #endif
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_POSIX_SOCKET_TCP_SERVER
@@ -49,7 +45,6 @@
 
 #include <grpc/byte_buffer.h>
 #include <grpc/event_engine/endpoint_config.h>
-#include <grpc/event_engine/event_engine.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
@@ -57,6 +52,7 @@
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/event_engine/default_event_engine.h"
+#include "src/core/lib/event_engine/memory_allocator_factory.h"
 #include "src/core/lib/event_engine/resolved_address_internal.h"
 #include "src/core/lib/event_engine/shim.h"
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
@@ -79,30 +75,14 @@
 #include "src/core/lib/transport/error_utils.h"
 
 static std::atomic<int64_t> num_dropped_connections{0};
-static constexpr grpc_core::Duration kRetryAcceptWaitTime{
-    grpc_core::Duration::Seconds(1)};
 
 using ::grpc_event_engine::experimental::EndpointConfig;
 using ::grpc_event_engine::experimental::EventEngine;
 using ::grpc_event_engine::experimental::MemoryAllocator;
+using ::grpc_event_engine::experimental::MemoryQuotaBasedMemoryAllocatorFactory;
 using ::grpc_event_engine::experimental::PosixEventEngineWithFdSupport;
 using ::grpc_event_engine::experimental::SliceBuffer;
 
-class MemoryAllocatorFactoryWrapper
-    : public grpc_event_engine::experimental::MemoryAllocatorFactory {
- public:
-  explicit MemoryAllocatorFactoryWrapper(
-      grpc_core::MemoryQuotaRefPtr memory_quota)
-      : memory_quota_(std::move(memory_quota)) {}
-
-  MemoryAllocator CreateMemoryAllocator(absl::string_view name) override {
-    return memory_quota_->CreateMemoryAllocator(name);
-  }
-
- private:
-  grpc_core::MemoryQuotaRefPtr memory_quota_;
-};
-
 static grpc_error_handle CreateEventEngineListener(
     grpc_tcp_server* s, grpc_closure* shutdown_complete,
     const EndpointConfig& config, grpc_tcp_server** server) {
@@ -196,7 +176,9 @@ static grpc_error_handle CreateEventEngineListener(
         delete s->fd_handler;
         delete s;
       },
-      config, std::make_unique<MemoryAllocatorFactoryWrapper>(s->memory_quota));
+      config,
+      std::make_unique<MemoryQuotaBasedMemoryAllocatorFactory>(
+          s->memory_quota));
   if (!listener.ok()) {
     delete s;
     *server = nullptr;
@@ -357,38 +339,22 @@ static void on_read(void* arg, grpc_error_handle err) {
     if (fd < 0) {
       if (errno == EINTR) {
         continue;
-      }
-      // 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.
-      if (errno == EMFILE) {
-        GRPC_LOG_EVERY_N_SEC(1, "%s",
-                             "File descriptor limit reached. Retrying.");
-        grpc_fd_notify_on_read(sp->emfd, &sp->read_closure);
-        if (gpr_atm_full_xchg(&sp->retry_timer_armed, true)) return;
-        grpc_timer_init(&sp->retry_timer,
-                        grpc_core::Timestamp::Now() + kRetryAcceptWaitTime,
-                        &sp->retry_closure);
-        return;
-      }
-      if (errno == EAGAIN || errno == ECONNABORTED || errno == EWOULDBLOCK) {
+      } else if (errno == EAGAIN || errno == ECONNABORTED ||
+                 errno == EWOULDBLOCK) {
         grpc_fd_notify_on_read(sp->emfd, &sp->read_closure);
         return;
-      }
-      gpr_mu_lock(&sp->server->mu);
-      if (!sp->server->shutdown_listeners) {
-        gpr_log(GPR_ERROR, "Failed accept4: %s",
-                grpc_core::StrError(errno).c_str());
       } else {
-        // if we have shutdown listeners, accept4 could fail, and we
-        // needn't notify users
+        gpr_mu_lock(&sp->server->mu);
+        if (!sp->server->shutdown_listeners) {
+          gpr_log(GPR_ERROR, "Failed accept4: %s",
+                  grpc_core::StrError(errno).c_str());
+        } else {
+          // if we have shutdown listeners, accept4 could fail, and we
+          // needn't notify users
+        }
+        gpr_mu_unlock(&sp->server->mu);
+        goto error;
       }
-      gpr_mu_unlock(&sp->server->mu);
-      goto error;
     }
 
     if (sp->server->memory_quota->IsMemoryPressureHigh()) {
@@ -581,7 +547,6 @@ static grpc_error_handle clone_port(grpc_tcp_listener* listener,
     sp->port_index = listener->port_index;
     sp->fd_index = listener->fd_index + count - i;
     GPR_ASSERT(sp->emfd);
-    grpc_tcp_server_listener_initialize_retry_timer(sp);
     while (listener->server->tail->next != nullptr) {
       listener->server->tail = listener->server->tail->next;
     }
@@ -815,7 +780,6 @@ static void tcp_server_shutdown_listeners(grpc_tcp_server* s) {
   if (s->active_ports) {
     grpc_tcp_listener* sp;
     for (sp = s->head; sp; sp = sp->next) {
-      grpc_timer_cancel(&sp->retry_timer);
       grpc_fd_shutdown(sp->emfd, GRPC_ERROR_CREATE("Server shutdown"));
     }
   }

data/src/core/lib/iomgr/tcp_server_utils_posix.h

@@ -30,7 +30,6 @@
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/socket_utils_posix.h"
 #include "src/core/lib/iomgr/tcp_server.h"
-#include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
 
 // one listening port
@@ -53,11 +52,6 @@ typedef struct grpc_tcp_listener {
   // identified while iterating through 'next'.
   struct grpc_tcp_listener* sibling;
   int is_sibling;
-  // If an accept4() call fails, a timer is started to drain the accept queue in
-  // case no further connection attempts reach the gRPC server.
-  grpc_closure retry_closure;
-  grpc_timer retry_timer;
-  gpr_atm retry_timer_armed;
 } grpc_tcp_listener;
 
 // the overall server
@@ -145,10 +139,4 @@ grpc_error_handle grpc_tcp_server_prepare_socket(
 // Ruturn true if the platform supports ifaddrs
 bool grpc_tcp_server_have_ifaddrs(void);
 
-// Initialize (but don't start) the timer and callback to retry accept4() on a
-// listening socket after file descriptors have been exhausted. This must be
-// called when creating a new listener.
-void grpc_tcp_server_listener_initialize_retry_timer(
-    grpc_tcp_listener* listener);
-
 #endif  // GRPC_SRC_CORE_LIB_IOMGR_TCP_SERVER_UTILS_POSIX_H

data/src/core/lib/iomgr/tcp_server_utils_posix_common.cc

@@ -18,8 +18,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/support/atm.h>
-
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_POSIX_SOCKET_TCP_SERVER_UTILS_COMMON
@@ -83,24 +81,6 @@ static int get_max_accept_queue_size(void) {
   return s_max_accept_queue_size;
 }
 
-static void listener_retry_timer_cb(void* arg, grpc_error_handle err) {
-  // Do nothing if cancelled.
-  if (!err.ok()) return;
-  grpc_tcp_listener* listener = static_cast<grpc_tcp_listener*>(arg);
-  gpr_atm_no_barrier_store(&listener->retry_timer_armed, false);
-  if (!grpc_fd_is_shutdown(listener->emfd)) {
-    grpc_fd_set_readable(listener->emfd);
-  }
-}
-
-void grpc_tcp_server_listener_initialize_retry_timer(
-    grpc_tcp_listener* listener) {
-  gpr_atm_no_barrier_store(&listener->retry_timer_armed, false);
-  grpc_timer_init_unset(&listener->retry_timer);
-  GRPC_CLOSURE_INIT(&listener->retry_closure, listener_retry_timer_cb, listener,
-                    grpc_schedule_on_exec_ctx);
-}
-
 static grpc_error_handle add_socket_to_server(grpc_tcp_server* s, int fd,
                                               const grpc_resolved_address* addr,
                                               unsigned port_index,
@@ -132,7 +112,6 @@ static grpc_error_handle add_socket_to_server(grpc_tcp_server* s, int fd,
   sp->server = s;
   sp->fd = fd;
   sp->emfd = grpc_fd_create(fd, name.c_str(), true);
-  grpc_tcp_server_listener_initialize_retry_timer(sp);
 
   // Check and set fd as prellocated
   if (grpc_tcp_server_pre_allocated_fd(s) == fd) {