grpc 1.54.2 → 1.61.0

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

@@ -14,13 +14,18 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <memory>
+#include <string>
+
 #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/forkable.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/no_destruct.h"
 #include "src/core/lib/iomgr/port.h"
 
 namespace grpc_event_engine {
@@ -28,15 +33,25 @@ namespace experimental {
 
 #ifdef GRPC_POSIX_SOCKET_TCP
 namespace {
+// TODO(yijiem): this object is thread-unsafe, if we are creating pollers in
+// multiple threads (e.g. multiple event engines) or if we are creating pollers
+// while we are forking then we will run into issues.
+grpc_core::NoDestruct<ObjectGroupForkHandler> g_poller_fork_manager;
+
+class PollerForkCallbackMethods {
+ public:
+  static void Prefork() { g_poller_fork_manager->Prefork(); }
+  static void PostforkParent() { g_poller_fork_manager->PostforkParent(); }
+  static void PostforkChild() { g_poller_fork_manager->PostforkChild(); }
+};
 
 bool PollStrategyMatches(absl::string_view strategy, absl::string_view want) {
   return strategy == "all" || strategy == want;
 }
-
 }  // namespace
 
-PosixEventPoller* MakeDefaultPoller(Scheduler* scheduler) {
-  PosixEventPoller* poller = nullptr;
+std::shared_ptr<PosixEventPoller> MakeDefaultPoller(Scheduler* scheduler) {
+  std::shared_ptr<PosixEventPoller> poller;
   auto strings =
       absl::StrSplit(grpc_core::ConfigVars::Get().PollStrategy(), ',');
   for (auto it = strings.begin(); it != strings.end() && poller == nullptr;
@@ -53,12 +68,16 @@ PosixEventPoller* MakeDefaultPoller(Scheduler* scheduler) {
       poller = MakePollPoller(scheduler, /*use_phony_poll=*/true);
     }
   }
+  g_poller_fork_manager->RegisterForkable(
+      poller, PollerForkCallbackMethods::Prefork,
+      PollerForkCallbackMethods::PostforkParent,
+      PollerForkCallbackMethods::PostforkChild);
   return poller;
 }
 
 #else  // GRPC_POSIX_SOCKET_TCP
 
-PosixEventPoller* MakeDefaultPoller(Scheduler* /*scheduler*/) {
+std::shared_ptr<PosixEventPoller> MakeDefaultPoller(Scheduler* /*scheduler*/) {
   return nullptr;
 }
 

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

@@ -17,6 +17,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <memory>
+
 namespace grpc_event_engine {
 namespace experimental {
 
@@ -25,7 +27,7 @@ class Scheduler;
 
 // Return an instance of an event poller which is tied to the specified
 // scheduler.
-PosixEventPoller* MakeDefaultPoller(Scheduler* scheduler);
+std::shared_ptr<PosixEventPoller> MakeDefaultPoller(Scheduler* scheduler);
 
 }  // namespace experimental
 }  // namespace grpc_event_engine

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

@@ -0,0 +1,205 @@
+// Copyright 2023 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_POSIX_ENGINE_GRPC_POLLED_FD_POSIX_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_GRPC_POLLED_FD_POSIX_H
+
+#include <grpc/support/port_platform.h>
+
+#include <memory>
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/iomgr/port.h"
+
+#if GRPC_ARES == 1 && defined(GRPC_POSIX_SOCKET_ARES_EV_DRIVER)
+
+// IWYU pragma: no_include <ares_build.h>
+
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <sys/uio.h>
+#include <unistd.h>
+
+#include <string>
+#include <unordered_set>
+#include <utility>
+
+#include <ares.h>
+
+#include "absl/functional/any_invocable.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+
+#include "src/core/lib/event_engine/grpc_polled_fd.h"
+#include "src/core/lib/event_engine/posix_engine/event_poller.h"
+#include "src/core/lib/event_engine/posix_engine/posix_engine_closure.h"
+#include "src/core/lib/event_engine/posix_engine/tcp_socket_utils.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+class GrpcPolledFdPosix : public GrpcPolledFd {
+ public:
+  GrpcPolledFdPosix(ares_socket_t as, EventHandle* handle)
+      : name_(absl::StrCat("c-ares fd: ", static_cast<int>(as))),
+        as_(as),
+        handle_(handle) {}
+
+  ~GrpcPolledFdPosix() override {
+    // c-ares library will close the fd. This fd may be picked up immediately by
+    // another thread and should not be closed by the following OrphanHandle.
+    int phony_release_fd;
+    handle_->OrphanHandle(/*on_done=*/nullptr, &phony_release_fd,
+                          "c-ares query finished");
+  }
+
+  void RegisterForOnReadableLocked(
+      absl::AnyInvocable<void(absl::Status)> read_closure) override {
+    handle_->NotifyOnRead(new PosixEngineClosure(std::move(read_closure),
+                                                 /*is_permanent=*/false));
+  }
+
+  void RegisterForOnWriteableLocked(
+      absl::AnyInvocable<void(absl::Status)> write_closure) override {
+    handle_->NotifyOnWrite(new PosixEngineClosure(std::move(write_closure),
+                                                  /*is_permanent=*/false));
+  }
+
+  bool IsFdStillReadableLocked() override {
+    size_t bytes_available = 0;
+    return ioctl(handle_->WrappedFd(), FIONREAD, &bytes_available) == 0 &&
+           bytes_available > 0;
+  }
+
+  bool ShutdownLocked(absl::Status error) override {
+    handle_->ShutdownHandle(error);
+    return true;
+  }
+
+  ares_socket_t GetWrappedAresSocketLocked() override { return as_; }
+
+  const char* GetName() const override { return name_.c_str(); }
+
+ private:
+  const std::string name_;
+  const ares_socket_t as_;
+  EventHandle* handle_;
+};
+
+class GrpcPolledFdFactoryPosix : public GrpcPolledFdFactory {
+ public:
+  explicit GrpcPolledFdFactoryPosix(PosixEventPoller* poller)
+      : poller_(poller) {}
+
+  ~GrpcPolledFdFactoryPosix() override {
+    for (auto& fd : owned_fds_) {
+      close(fd);
+    }
+  }
+
+  void Initialize(grpc_core::Mutex*, EventEngine*) override {}
+
+  std::unique_ptr<GrpcPolledFd> NewGrpcPolledFdLocked(
+      ares_socket_t as) override {
+    owned_fds_.insert(as);
+    return std::make_unique<GrpcPolledFdPosix>(
+        as,
+        poller_->CreateHandle(as, "c-ares socket", poller_->CanTrackErrors()));
+  }
+
+  void ConfigureAresChannelLocked(ares_channel channel) override {
+    ares_set_socket_functions(channel, &kSockFuncs, this);
+    ares_set_socket_configure_callback(
+        channel, &GrpcPolledFdFactoryPosix::ConfigureSocket, nullptr);
+  }
+
+ private:
+  /// Overridden socket API for c-ares
+  static ares_socket_t Socket(int af, int type, int protocol,
+                              void* /*user_data*/) {
+    return socket(af, type, protocol);
+  }
+
+  /// Overridden connect API for c-ares
+  static int Connect(ares_socket_t as, const struct sockaddr* target,
+                     ares_socklen_t target_len, void* /*user_data*/) {
+    return connect(as, target, target_len);
+  }
+
+  /// Overridden writev API for c-ares
+  static ares_ssize_t WriteV(ares_socket_t as, const struct iovec* iov,
+                             int iovec_count, void* /*user_data*/) {
+    return writev(as, iov, iovec_count);
+  }
+
+  /// Overridden recvfrom API for c-ares
+  static ares_ssize_t RecvFrom(ares_socket_t as, void* data, size_t data_len,
+                               int flags, struct sockaddr* from,
+                               ares_socklen_t* from_len, void* /*user_data*/) {
+    return recvfrom(as, data, data_len, flags, from, from_len);
+  }
+
+  /// Overridden close API for c-ares
+  static int Close(ares_socket_t as, void* user_data) {
+    GrpcPolledFdFactoryPosix* self =
+        static_cast<GrpcPolledFdFactoryPosix*>(user_data);
+    if (self->owned_fds_.find(as) == self->owned_fds_.end()) {
+      // c-ares owns this fd, grpc has never seen it
+      return close(as);
+    }
+    return 0;
+  }
+
+  /// Because we're using socket API overrides, c-ares won't
+  /// perform its typical configuration on the socket. See
+  /// https://github.com/c-ares/c-ares/blob/bad62225b7f6b278b92e8e85a255600b629ef517/src/lib/ares_process.c#L1018.
+  /// So we use the configure socket callback override and copy default
+  /// settings that c-ares would normally apply on posix platforms:
+  ///   - non-blocking
+  ///   - cloexec flag
+  ///   - disable nagle
+  static int ConfigureSocket(ares_socket_t fd, int type, void* /*user_data*/) {
+    // clang-format off
+#define RETURN_IF_ERROR(expr) if (!(expr).ok()) { return -1; }
+    // clang-format on
+    PosixSocketWrapper sock(fd);
+    RETURN_IF_ERROR(sock.SetSocketNonBlocking(1));
+    RETURN_IF_ERROR(sock.SetSocketCloexec(1));
+    if (type == SOCK_STREAM) {
+      RETURN_IF_ERROR(sock.SetSocketLowLatency(1));
+    }
+    return 0;
+  }
+
+  const struct ares_socket_functions kSockFuncs = {
+      &GrpcPolledFdFactoryPosix::Socket /* socket */,
+      &GrpcPolledFdFactoryPosix::Close /* close */,
+      &GrpcPolledFdFactoryPosix::Connect /* connect */,
+      &GrpcPolledFdFactoryPosix::RecvFrom /* recvfrom */,
+      &GrpcPolledFdFactoryPosix::WriteV /* writev */,
+  };
+
+  PosixEventPoller* poller_;
+  // fds that are used/owned by grpc - we (grpc) will close them rather than
+  // c-ares
+  std::unordered_set<ares_socket_t> owned_fds_;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_ARES == 1 && defined(GRPC_POSIX_SOCKET_ARES_EV_DRIVER)
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_GRPC_POLLED_FD_POSIX_H

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

@@ -16,8 +16,6 @@
 
 #include "src/core/lib/event_engine/posix_engine/internal_errqueue.h"
 
-#include <string>
-
 #include <grpc/support/log.h>
 
 #include "src/core/lib/iomgr/port.h"

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

@@ -86,7 +86,7 @@ void LockfreeEvent::DestroyEvent() {
     // pattern to prevent error retention in a deleted object
   } while (!state_.compare_exchange_strong(curr, kShutdownBit,
                                            std::memory_order_acq_rel,
-                                           std::memory_order_relaxed));
+                                           std::memory_order_acquire));
 }
 
 void LockfreeEvent::NotifyOn(PosixEngineClosure* closure) {
@@ -103,14 +103,9 @@ void LockfreeEvent::NotifyOn(PosixEngineClosure* closure) {
       case kClosureNotReady: {
         // kClosureNotReady -> <closure>.
 
-        // We're guaranteed by API that there's an acquire barrier before here,
-        // so there's no need to double-dip and this can be a release-only.
-
-        // The release itself pairs with the acquire half of a set_ready full
-        // barrier.
         if (state_.compare_exchange_strong(
                 curr, reinterpret_cast<intptr_t>(closure),
-                std::memory_order_acq_rel, std::memory_order_relaxed)) {
+                std::memory_order_acq_rel, std::memory_order_acquire)) {
           return;  // Successful. Return
         }
 
@@ -122,13 +117,9 @@ void LockfreeEvent::NotifyOn(PosixEngineClosure* closure) {
         // successful. If not, the state most likely transitioned to shutdown.
         // We should retry.
 
-        // This can be a no-barrier cas since the state is being transitioned to
-        // kClosureNotReady; set_ready and set_shutdown do not schedule any
-        // closure when transitioning out of CLOSURE_NO_READY state (i.e there
-        // is no other code that needs to 'happen-after' this)
         if (state_.compare_exchange_strong(curr, kClosureNotReady,
                                            std::memory_order_acq_rel,
-                                           std::memory_order_relaxed)) {
+                                           std::memory_order_acquire)) {
           scheduler_->Run(closure);
           return;  // Successful. Return.
         }
@@ -175,7 +166,7 @@ bool LockfreeEvent::SetShutdown(absl::Status shutdown_error) {
         // doesn't need a barrier
         if (state_.compare_exchange_strong(curr, new_state,
                                            std::memory_order_acq_rel,
-                                           std::memory_order_relaxed)) {
+                                           std::memory_order_acquire)) {
           return true;  // early out
         }
         break;  // retry
@@ -196,7 +187,7 @@ bool LockfreeEvent::SetShutdown(absl::Status shutdown_error) {
         // loading the shutdown state.
         if (state_.compare_exchange_strong(curr, new_state,
                                            std::memory_order_acq_rel,
-                                           std::memory_order_relaxed)) {
+                                           std::memory_order_acquire)) {
           auto closure = reinterpret_cast<PosixEngineClosure*>(curr);
           closure->SetStatus(shutdown_error);
           scheduler_->Run(closure);
@@ -225,11 +216,9 @@ void LockfreeEvent::SetReady() {
       }
 
       case kClosureNotReady: {
-        // No barrier required as we're transitioning to a state that does not
-        // involve a closure
         if (state_.compare_exchange_strong(curr, kClosureReady,
                                            std::memory_order_acq_rel,
-                                           std::memory_order_relaxed)) {
+                                           std::memory_order_acquire)) {
           return;  // early out
         }
         break;  // retry
@@ -242,7 +231,7 @@ void LockfreeEvent::SetReady() {
           return;
         } else if (state_.compare_exchange_strong(curr, kClosureNotReady,
                                                   std::memory_order_acq_rel,
-                                                  std::memory_order_relaxed)) {
+                                                  std::memory_order_acquire)) {
           // Full cas: acquire pairs with this cas' release in the event of a
           // spurious set_ready; release pairs with this or the acquire in
           // notify_on (or set_shutdown)

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

@@ -0,0 +1,132 @@
+// Copyright 2023 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.
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/iomgr/port.h"
+
+#ifdef GRPC_POSIX_SOCKET_RESOLVE_ADDRESS
+
+#include <netdb.h>
+#include <string.h>
+#include <sys/socket.h>
+
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "absl/functional/any_invocable.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
+
+#include "src/core/lib/event_engine/posix_engine/native_posix_dns_resolver.h"
+#include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/host_port.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+namespace {
+
+absl::StatusOr<std::vector<EventEngine::ResolvedAddress>>
+LookupHostnameBlocking(absl::string_view name, absl::string_view default_port) {
+  struct addrinfo hints;
+  struct addrinfo *result = nullptr, *resp;
+  std::string host;
+  std::string port;
+  // parse name, splitting it into host and port parts
+  grpc_core::SplitHostPort(name, &host, &port);
+  if (host.empty()) {
+    return absl::InvalidArgumentError(absl::StrCat("Unparseable name: ", name));
+  }
+  if (port.empty()) {
+    if (default_port.empty()) {
+      return absl::InvalidArgumentError(
+          absl::StrFormat("No port in name %s or default_port argument", name));
+    }
+    port = std::string(default_port);
+  }
+  // Call getaddrinfo
+  memset(&hints, 0, sizeof(hints));
+  hints.ai_family = AF_UNSPEC;      // ipv4 or ipv6
+  hints.ai_socktype = SOCK_STREAM;  // stream socket
+  hints.ai_flags = AI_PASSIVE;      // for wildcard IP address
+  int s = getaddrinfo(host.c_str(), port.c_str(), &hints, &result);
+  if (s != 0) {
+    // Retry if well-known service name is recognized
+    const char* svc[][2] = {{"http", "80"}, {"https", "443"}};
+    for (size_t i = 0; i < GPR_ARRAY_SIZE(svc); i++) {
+      if (port == svc[i][0]) {
+        s = getaddrinfo(host.c_str(), svc[i][1], &hints, &result);
+        break;
+      }
+    }
+  }
+  if (s != 0) {
+    return absl::UnknownError(absl::StrFormat(
+        "Address lookup failed for %s os_error: %s syscall: getaddrinfo", name,
+        gai_strerror(s)));
+  }
+  // Success path: fill in addrs
+  std::vector<EventEngine::ResolvedAddress> addresses;
+  for (resp = result; resp != nullptr; resp = resp->ai_next) {
+    addresses.emplace_back(resp->ai_addr, resp->ai_addrlen);
+  }
+  if (result) {
+    freeaddrinfo(result);
+  }
+  return addresses;
+}
+
+}  // namespace
+
+NativePosixDNSResolver::NativePosixDNSResolver(
+    std::shared_ptr<EventEngine> event_engine)
+    : event_engine_(std::move(event_engine)) {}
+
+void NativePosixDNSResolver::LookupHostname(
+    EventEngine::DNSResolver::LookupHostnameCallback on_resolved,
+    absl::string_view name, absl::string_view default_port) {
+  event_engine_->Run(
+      [name, default_port, on_resolved = std::move(on_resolved)]() mutable {
+        on_resolved(LookupHostnameBlocking(name, default_port));
+      });
+}
+
+void NativePosixDNSResolver::LookupSRV(
+    EventEngine::DNSResolver::LookupSRVCallback on_resolved,
+    absl::string_view /* name */) {
+  // Not supported
+  event_engine_->Run([on_resolved = std::move(on_resolved)]() mutable {
+    on_resolved(absl::UnimplementedError(
+        "The Native resolver does not support looking up SRV records"));
+  });
+}
+
+void NativePosixDNSResolver::LookupTXT(
+    EventEngine::DNSResolver::LookupTXTCallback on_resolved,
+    absl::string_view /* name */) {
+  // Not supported
+  event_engine_->Run([on_resolved = std::move(on_resolved)]() mutable {
+    on_resolved(absl::UnimplementedError(
+        "The Native resolver does not support looking up TXT records"));
+  });
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_POSIX_SOCKET_RESOLVE_ADDRESS

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

@@ -0,0 +1,61 @@
+// Copyright 2023 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_POSIX_ENGINE_NATIVE_POSIX_DNS_RESOLVER_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_NATIVE_POSIX_DNS_RESOLVER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <memory>
+
+#include "absl/strings/string_view.h"
+
+#include "src/core/lib/iomgr/port.h"
+
+#ifdef GRPC_POSIX_SOCKET_RESOLVE_ADDRESS
+
+#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 {
+ public:
+  explicit NativePosixDNSResolver(std::shared_ptr<EventEngine> event_engine);
+
+  void LookupHostname(
+      EventEngine::DNSResolver::LookupHostnameCallback on_resolved,
+      absl::string_view name, absl::string_view default_port) override;
+
+  void LookupSRV(EventEngine::DNSResolver::LookupSRVCallback on_resolved,
+                 absl::string_view name) override;
+
+  void LookupTXT(EventEngine::DNSResolver::LookupTXTCallback on_resolved,
+                 absl::string_view name) override;
+
+  void Orphan() override { delete this; }
+
+ private:
+  std::shared_ptr<EventEngine> event_engine_;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_POSIX_SOCKET_RESOLVE_ADDRESS
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_NATIVE_POSIX_DNS_RESOLVER_H

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

@@ -49,7 +49,9 @@
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/gprpp/strerror.h"
+#include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/resource_quota/resource_quota.h"
 #include "src/core/lib/slice/slice.h"
 
@@ -519,7 +521,7 @@ void PosixEndpointImpl::UpdateRcvLowat() {
 void PosixEndpointImpl::MaybeMakeReadSlices() {
   static const int kBigAlloc = 64 * 1024;
   static const int kSmallAlloc = 8 * 1024;
-  if (incoming_buffer_->Length() < static_cast<size_t>(min_progress_size_)) {
+  if (incoming_buffer_->Length() < std::max<size_t>(min_progress_size_, 1)) {
     size_t allocate_length = min_progress_size_;
     const size_t target_length = static_cast<size_t>(target_length_);
     // If memory pressure is low and we think there will be more than
@@ -529,8 +531,8 @@ void PosixEndpointImpl::MaybeMakeReadSlices() {
     if (low_memory_pressure && target_length > allocate_length) {
       allocate_length = target_length;
     }
-    int extra_wanted =
-        allocate_length - static_cast<int>(incoming_buffer_->Length());
+    int extra_wanted = std::max<int>(
+        1, allocate_length - static_cast<int>(incoming_buffer_->Length()));
     if (extra_wanted >=
         (low_memory_pressure ? kSmallAlloc * 3 / 2 : kBigAlloc)) {
       while (extra_wanted > 0) {
@@ -549,28 +551,40 @@ void PosixEndpointImpl::MaybeMakeReadSlices() {
   }
 }
 
-void PosixEndpointImpl::HandleRead(absl::Status status) {
-  read_mu_.Lock();
+bool PosixEndpointImpl::HandleReadLocked(absl::Status& status) {
   if (status.ok() && memory_owner_.is_valid()) {
     MaybeMakeReadSlices();
     if (!TcpDoRead(status)) {
       UpdateRcvLowat();
       // We've consumed the edge, request a new one.
-      read_mu_.Unlock();
-      handle_->NotifyOnRead(on_read_);
-      return;
+      return false;
     }
   } else {
-    if (!memory_owner_.is_valid()) {
-      status = absl::UnknownError("Shutting down endpoint");
+    if (!memory_owner_.is_valid() && status.ok()) {
+      status = TcpAnnotateError(absl::UnknownError("Shutting down endpoint"));
     }
     incoming_buffer_->Clear();
     last_read_buffer_.Clear();
   }
-  absl::AnyInvocable<void(absl::Status)> cb = std::move(read_cb_);
-  read_cb_ = nullptr;
-  incoming_buffer_ = nullptr;
-  read_mu_.Unlock();
+  return true;
+}
+
+void PosixEndpointImpl::HandleRead(absl::Status status) {
+  bool ret = false;
+  absl::AnyInvocable<void(absl::Status)> cb = nullptr;
+  grpc_core::EnsureRunInExecCtx([&, this]() mutable {
+    grpc_core::MutexLock lock(&read_mu_);
+    ret = HandleReadLocked(status);
+    if (ret) {
+      cb = std::move(read_cb_);
+      read_cb_ = nullptr;
+      incoming_buffer_ = nullptr;
+    }
+  });
+  if (!ret) {
+    handle_->NotifyOnRead(on_read_);
+    return;
+  }
   cb(status);
   Unref();
 }
@@ -1232,8 +1246,7 @@ PosixEndpointImpl::PosixEndpointImpl(EventHandle* handle,
   GPR_ASSERT(options.resource_quota != nullptr);
   auto peer_addr_string = sock.PeerAddressString();
   mem_quota_ = options.resource_quota->memory_quota();
-  memory_owner_ = mem_quota_->CreateMemoryOwner(
-      peer_addr_string.ok() ? *peer_addr_string : "");
+  memory_owner_ = mem_quota_->CreateMemoryOwner();
   self_reservation_ = memory_owner_.MakeReservation(sizeof(PosixEndpointImpl));
   auto local_address = sock.LocalAddress();
   if (local_address.ok()) {