grpc 1.58.0 → 1.62.0

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

@@ -17,8 +17,11 @@
 
 #include <atomic>
 #include <memory>
+#include <utility>
 
+#include "absl/functional/any_invocable.h"
 #include "absl/status/status.h"
+#include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
 #include <grpc/event_engine/event_engine.h>
@@ -28,7 +31,9 @@
 #include <grpc/support/log.h>
 #include <grpc/support/time.h>
 
-#include "src/core/lib/event_engine/posix.h"
+#include "src/core/lib/event_engine/extensions/can_track_errors.h"
+#include "src/core/lib/event_engine/extensions/supports_fd.h"
+#include "src/core/lib/event_engine/query_extensions.h"
 #include "src/core/lib/event_engine/shim.h"
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
 #include "src/core/lib/event_engine/trace.h"
@@ -60,15 +65,19 @@ class EventEngineEndpointWrapper {
   struct grpc_event_engine_endpoint {
     grpc_endpoint base;
     EventEngineEndpointWrapper* wrapper;
-    std::aligned_storage<sizeof(SliceBuffer), alignof(SliceBuffer)>::type
-        read_buffer;
-    std::aligned_storage<sizeof(SliceBuffer), alignof(SliceBuffer)>::type
-        write_buffer;
+    alignas(SliceBuffer) char read_buffer[sizeof(SliceBuffer)];
+    alignas(SliceBuffer) char write_buffer[sizeof(SliceBuffer)];
   };
 
   explicit EventEngineEndpointWrapper(
       std::unique_ptr<EventEngine::Endpoint> endpoint);
 
+  EventEngine::Endpoint* endpoint() { return endpoint_.get(); }
+
+  std::unique_ptr<EventEngine::Endpoint> ReleaseEndpoint() {
+    return std::move(endpoint_);
+  }
+
   int Fd() {
     grpc_core::MutexLock lock(&mu_);
     return fd_;
@@ -210,9 +219,10 @@ class EventEngineEndpointWrapper {
   void ShutdownUnref() {
     if (shutdown_ref_.fetch_sub(1, std::memory_order_acq_rel) ==
         kShutdownBit + 1) {
-      if (EventEngineSupportsFd() && fd_ > 0 && on_release_fd_) {
-        reinterpret_cast<PosixEndpointWithFdSupport*>(endpoint_.get())
-            ->Shutdown(std::move(on_release_fd_));
+      auto* supports_fd =
+          QueryExtension<EndpointSupportsFdExtension>(endpoint_.get());
+      if (supports_fd != nullptr && fd_ > 0 && on_release_fd_) {
+        supports_fd->Shutdown(std::move(on_release_fd_));
       }
       OnShutdownInternal();
     }
@@ -224,7 +234,9 @@ class EventEngineEndpointWrapper {
   // invocation would simply return.
   void TriggerShutdown(
       absl::AnyInvocable<void(absl::StatusOr<int>)> on_release_fd) {
-    if (EventEngineSupportsFd()) {
+    auto* supports_fd =
+        QueryExtension<EndpointSupportsFdExtension>(endpoint_.get());
+    if (supports_fd != nullptr) {
       on_release_fd_ = std::move(on_release_fd);
     }
     int64_t curr = shutdown_ref_.load(std::memory_order_acquire);
@@ -238,9 +250,8 @@ class EventEngineEndpointWrapper {
         Ref();
         if (shutdown_ref_.fetch_sub(1, std::memory_order_acq_rel) ==
             kShutdownBit + 1) {
-          if (EventEngineSupportsFd() && fd_ > 0 && on_release_fd_) {
-            reinterpret_cast<PosixEndpointWithFdSupport*>(endpoint_.get())
-                ->Shutdown(std::move(on_release_fd_));
+          if (supports_fd != nullptr && fd_ > 0 && on_release_fd_) {
+            supports_fd->Shutdown(std::move(on_release_fd_));
           }
           OnShutdownInternal();
         }
@@ -250,9 +261,10 @@ class EventEngineEndpointWrapper {
   }
 
   bool CanTrackErrors() {
-    if (EventEngineSupportsFd()) {
-      return reinterpret_cast<PosixEndpointWithFdSupport*>(endpoint_.get())
-          ->CanTrackErrors();
+    auto* can_track_errors =
+        QueryExtension<EndpointCanTrackErrorsExtension>(endpoint_.get());
+    if (can_track_errors != nullptr) {
+      return can_track_errors->CanTrackErrors();
     } else {
       return false;
     }
@@ -406,9 +418,10 @@ EventEngineEndpointWrapper::EventEngineEndpointWrapper(
       eeep_(std::make_unique<grpc_event_engine_endpoint>()) {
   eeep_->base.vtable = &grpc_event_engine_endpoint_vtable;
   eeep_->wrapper = this;
-  if (EventEngineSupportsFd()) {
-    fd_ = reinterpret_cast<PosixEndpointWithFdSupport*>(endpoint_.get())
-              ->GetWrappedFd();
+  auto* supports_fd =
+      QueryExtension<EndpointSupportsFdExtension>(endpoint_.get());
+  if (supports_fd != nullptr) {
+    fd_ = supports_fd->GetWrappedFd();
   } else {
     fd_ = -1;
   }
@@ -428,6 +441,30 @@ bool grpc_is_event_engine_endpoint(grpc_endpoint* ep) {
   return ep->vtable == &grpc_event_engine_endpoint_vtable;
 }
 
+EventEngine::Endpoint* grpc_get_wrapped_event_engine_endpoint(
+    grpc_endpoint* ep) {
+  if (!grpc_is_event_engine_endpoint(ep)) {
+    return nullptr;
+  }
+  auto* eeep =
+      reinterpret_cast<EventEngineEndpointWrapper::grpc_event_engine_endpoint*>(
+          ep);
+  return eeep->wrapper->endpoint();
+}
+
+std::unique_ptr<EventEngine::Endpoint> grpc_take_wrapped_event_engine_endpoint(
+    grpc_endpoint* ep) {
+  if (!grpc_is_event_engine_endpoint(ep)) {
+    return nullptr;
+  }
+  auto* eeep =
+      reinterpret_cast<EventEngineEndpointWrapper::grpc_event_engine_endpoint*>(
+          ep);
+  auto endpoint = eeep->wrapper->ReleaseEndpoint();
+  delete eeep->wrapper;
+  return endpoint;
+}
+
 void grpc_event_engine_endpoint_destroy_and_release_fd(
     grpc_endpoint* ep, int* fd, grpc_closure* on_release_fd) {
   auto* eeep =

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

@@ -15,6 +15,8 @@
 #define GRPC_SRC_CORE_LIB_IOMGR_EVENT_ENGINE_SHIMS_ENDPOINT_H
 #include <grpc/support/port_platform.h>
 
+#include <memory>
+
 #include <grpc/event_engine/event_engine.h>
 
 #include "src/core/lib/iomgr/endpoint.h"
@@ -31,6 +33,20 @@ grpc_endpoint* grpc_event_engine_endpoint_create(
 /// Returns true if the passed endpoint is an event engine shim endpoint.
 bool grpc_is_event_engine_endpoint(grpc_endpoint* ep);
 
+/// Returns the wrapped event engine endpoint if the given grpc_endpoint is an
+/// event engine shim endpoint. Otherwise it returns nullptr.
+EventEngine::Endpoint* grpc_get_wrapped_event_engine_endpoint(
+    grpc_endpoint* ep);
+
+/// Transfers ownership of the wrapped event engine endpoint if the given
+/// grpc_endpoint is an event engine shim endpoint. Otherwise it returns
+/// nullptr. If the passed ep wraps an event_engine endpoint, then after this
+/// call, the memory location holding by the passed ep is free'ed.
+/// Its safe to call this function only when there are no pending reads/writes
+/// on the endpoint.
+std::unique_ptr<EventEngine::Endpoint> grpc_take_wrapped_event_engine_endpoint(
+    grpc_endpoint* ep);
+
 /// Destroys the passed in event engine shim endpoint and schedules the
 /// asynchronous execution of the on_release_fd callback. The int pointer fd is
 /// set to the underlying endpoint's file descriptor.

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

@@ -16,6 +16,8 @@
 #include "src/core/lib/iomgr/event_engine_shims/tcp_client.h"
 
 #include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 
 #include <grpc/event_engine/event_engine.h>
@@ -70,8 +72,7 @@ int64_t event_engine_tcp_client_connect(
       },
       CreateResolvedAddress(*addr), config,
       resource_quota != nullptr
-          ? resource_quota->memory_quota()->CreateMemoryOwner(
-                absl::StrCat("tcp-client:", addr_uri.value()))
+          ? resource_quota->memory_quota()->CreateMemoryOwner()
           : grpc_event_engine::experimental::MemoryAllocator(),
       std::max(grpc_core::Duration::Milliseconds(1),
                deadline - grpc_core::Timestamp::Now()));

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

@@ -56,9 +56,21 @@ static void exec_ctx_sched(grpc_closure* closure) {
 
 namespace grpc_core {
 
+#if !defined(_WIN32) || !defined(_DLL)
 thread_local ExecCtx* ExecCtx::exec_ctx_;
 thread_local ApplicationCallbackExecCtx*
     ApplicationCallbackExecCtx::callback_exec_ctx_;
+#else   // _WIN32
+ExecCtx*& ExecCtx::exec_ctx() {
+  static thread_local ExecCtx* exec_ctx;
+  return exec_ctx;
+}
+
+ApplicationCallbackExecCtx*& ApplicationCallbackExecCtx::callback_exec_ctx() {
+  static thread_local ApplicationCallbackExecCtx* callback_exec_ctx;
+  return callback_exec_ctx;
+}
+#endif  // _WIN32
 
 bool ExecCtx::Flush() {
   bool did_something = false;

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

@@ -23,6 +23,11 @@
 
 #include <limits>
 
+#if __APPLE__
+// Provides TARGET_OS_IPHONE
+#include <TargetConditionals.h>
+#endif
+
 #include <grpc/impl/grpc_types.h>
 #include <grpc/support/atm.h>
 #include <grpc/support/cpu.h>
@@ -36,6 +41,14 @@
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/closure.h"
 
+#if !defined(_WIN32) || !defined(_DLL)
+#define EXEC_CTX exec_ctx_
+#define CALLBACK_EXEC_CTX callback_exec_ctx_
+#else
+#define EXEC_CTX exec_ctx()
+#define CALLBACK_EXEC_CTX callback_exec_ctx()
+#endif
+
 /// A combiner represents a list of work to be executed later.
 /// Forward declared here to avoid a circular dependency with combiner.h.
 typedef struct grpc_combiner grpc_combiner;
@@ -94,7 +107,7 @@ class Combiner;
 ///               since that implies a core re-entry outside of application
 ///               callbacks.
 ///
-class ExecCtx {
+class GRPC_DLL ExecCtx {
  public:
   /// Default Constructor
 
@@ -125,13 +138,6 @@ class ExecCtx {
   ExecCtx(const ExecCtx&) = delete;
   ExecCtx& operator=(const ExecCtx&) = delete;
 
-  unsigned starting_cpu() {
-    if (starting_cpu_ == std::numeric_limits<unsigned>::max()) {
-      starting_cpu_ = gpr_cpu_current_cpu();
-    }
-    return starting_cpu_;
-  }
-
   struct CombinerData {
     // currently active combiner: updated only via combiner.c
     Combiner* active_combiner;
@@ -176,17 +182,32 @@ class ExecCtx {
     }
   }
 
+  void SetReadyToFinishFlag() { flags_ |= GRPC_EXEC_CTX_FLAG_IS_FINISHED; }
+
   Timestamp Now() { return Timestamp::Now(); }
-  void InvalidateNow() { time_cache_.InvalidateCache(); }
+
+  void InvalidateNow() {
+#if !TARGET_OS_IPHONE
+    time_cache_.InvalidateCache();
+#endif
+  }
+
   void SetNowIomgrShutdown() {
+#if !TARGET_OS_IPHONE
     // We get to do a test only set now on this path just because iomgr
     // is getting removed and no point adding more interfaces for it.
     time_cache_.TestOnlySetNow(Timestamp::InfFuture());
+#endif
+  }
+
+  void TestOnlySetNow(Timestamp now) {
+#if !TARGET_OS_IPHONE
+    time_cache_.TestOnlySetNow(now);
+#endif
   }
-  void TestOnlySetNow(Timestamp now) { time_cache_.TestOnlySetNow(now); }
 
   /// Gets pointer to current exec_ctx.
-  static ExecCtx* Get() { return exec_ctx_; }
+  static ExecCtx* Get() { return EXEC_CTX; }
 
   static void Run(const DebugLocation& location, grpc_closure* closure,
                   grpc_error_handle error);
@@ -201,17 +222,23 @@ class ExecCtx {
   static void operator delete(void* /* p */) { abort(); }
 
  private:
-  /// Set exec_ctx_ to exec_ctx.
-  static void Set(ExecCtx* exec_ctx) { exec_ctx_ = exec_ctx; }
+  /// Set EXEC_CTX to ctx.
+  static void Set(ExecCtx* ctx) { EXEC_CTX = ctx; }
 
   grpc_closure_list closure_list_ = GRPC_CLOSURE_LIST_INIT;
   CombinerData combiner_data_ = {nullptr, nullptr};
   uintptr_t flags_;
 
-  unsigned starting_cpu_ = std::numeric_limits<unsigned>::max();
-
+#if !TARGET_OS_IPHONE
   ScopedTimeCache time_cache_;
+#endif
+
+#if !defined(_WIN32) || !defined(_DLL)
   static thread_local ExecCtx* exec_ctx_;
+#else
+  // cannot be thread_local data member (e.g. exec_ctx_) on windows
+  static ExecCtx*& exec_ctx();
+#endif
   ExecCtx* last_exec_ctx_ = Get();
 };
 
@@ -262,7 +289,7 @@ class ExecCtx {
 ///
 ///
 
-class ApplicationCallbackExecCtx {
+class GRPC_DLL ApplicationCallbackExecCtx {
  public:
   /// Default Constructor
   ApplicationCallbackExecCtx() { Set(this, flags_); }
@@ -282,7 +309,7 @@ class ApplicationCallbackExecCtx {
         }
         (*f->functor_run)(f, f->internal_success);
       }
-      callback_exec_ctx_ = nullptr;
+      CALLBACK_EXEC_CTX = nullptr;
       if (!(GRPC_APP_CALLBACK_EXEC_CTX_FLAG_IS_INTERNAL_THREAD & flags_)) {
         Fork::DecExecCtxCount();
       }
@@ -294,14 +321,14 @@ class ApplicationCallbackExecCtx {
 
   uintptr_t Flags() { return flags_; }
 
-  static ApplicationCallbackExecCtx* Get() { return callback_exec_ctx_; }
+  static ApplicationCallbackExecCtx* Get() { return CALLBACK_EXEC_CTX; }
 
   static void Set(ApplicationCallbackExecCtx* exec_ctx, uintptr_t flags) {
     if (Get() == nullptr) {
       if (!(GRPC_APP_CALLBACK_EXEC_CTX_FLAG_IS_INTERNAL_THREAD & flags)) {
         Fork::IncExecCtxCount();
       }
-      callback_exec_ctx_ = exec_ctx;
+      CALLBACK_EXEC_CTX = exec_ctx;
     }
   }
 
@@ -326,7 +353,13 @@ class ApplicationCallbackExecCtx {
   uintptr_t flags_{0u};
   grpc_completion_queue_functor* head_{nullptr};
   grpc_completion_queue_functor* tail_{nullptr};
+
+#if !defined(_WIN32) || !defined(_DLL)
   static thread_local ApplicationCallbackExecCtx* callback_exec_ctx_;
+#else
+  // cannot be thread_local data member (e.g. callback_exec_ctx_) on windows
+  static ApplicationCallbackExecCtx*& callback_exec_ctx();
+#endif
 };
 
 template <typename F>
@@ -340,6 +373,9 @@ void EnsureRunInExecCtx(F f) {
   }
 }
 
+#undef EXEC_CTX
+#undef CALLBACK_EXEC_CTX
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_IOMGR_EXEC_CTX_H

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

@@ -39,5 +39,5 @@ uint32_t grpc_if_nametoindex(char* name) {
   return out;
 }
 
-#endif  // GRPC_IF_NAMETOINDEX == 1 && \
-       // defined(GRPC_POSIX_SOCKET_IF_NAMETOINDEX)
+#endif  // GRPC_IF_NAMETOINDEX == 1 &&
+        // defined(GRPC_POSIX_SOCKET_IF_NAMETOINDEX)

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

@@ -35,5 +35,5 @@ uint32_t grpc_if_nametoindex(char* name) {
   return 0;
 }
 
-#endif  // GRPC_IF_NAMETOINDEX == 0 || \
-       // !defined(GRPC_POSIX_SOCKET_IF_NAMETOINDEX)
+#endif  // GRPC_IF_NAMETOINDEX == 0 ||
+        // !defined(GRPC_POSIX_SOCKET_IF_NAMETOINDEX)

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

@@ -98,3 +98,13 @@ void grpc_polling_entity_del_from_pollset_set(grpc_polling_entity* pollent,
         absl::StrFormat("Invalid grpc_polling_entity tag '%d'", pollent->tag));
   }
 }
+
+std::string grpc_polling_entity_string(grpc_polling_entity* pollent) {
+  if (pollent->tag == GRPC_POLLS_POLLSET) {
+    return absl::StrFormat("pollset:%p", pollent->pollent.pollset);
+  } else if (pollent->tag == GRPC_POLLS_POLLSET_SET) {
+    return absl::StrFormat("pollset_set:%p", pollent->pollent.pollset_set);
+  } else {
+    return absl::StrFormat("invalid_tag:%d", pollent->tag);
+  }
+}

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

@@ -66,6 +66,8 @@ void grpc_polling_entity_add_to_pollset_set(grpc_polling_entity* pollent,
 void grpc_polling_entity_del_from_pollset_set(grpc_polling_entity* pollent,
                                               grpc_pollset_set* pss_dst);
 
+std::string grpc_polling_entity_string(grpc_polling_entity* pollent);
+
 namespace grpc_core {
 template <>
 struct ContextType<grpc_polling_entity> {};

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

@@ -209,6 +209,20 @@
 #define GRPC_POSIX_SOCKET 1
 #define GRPC_POSIX_SOCKETUTILS 1
 #define GRPC_POSIX_WAKEUP_FD 1
+#elif defined(__QNX__) || defined(__QNXNTO__)
+#define GRPC_HAVE_ARPA_NAMESER 1
+#define GRPC_HAVE_IFADDRS 1
+#define GRPC_HAVE_IPV6_RECVPKTINFO 1
+#define GRPC_HAVE_IP_PKTINFO 1
+#define GRPC_HAVE_MSG_NOSIGNAL 1
+#define GRPC_HAVE_UNIX_SOCKET 1
+// TODO(rbyshliaha): Find a way to understand if VSOCK package is installed in
+//                   a toolchain to enable GRPC_HAVE_VSOCK.
+#define GRPC_POSIX_SOCKET 1
+#define GRPC_POSIX_WAKEUP_FD 1
+#define GRPC_POSIX_NO_SPECIAL_WAKEUP_FD 1
+#define GRPC_POSIX_SOCKETUTILS 1
+#define GRPC_POSIX_SYSCONF 1
 #elif !defined(GPR_NO_AUTODETECT_PLATFORM)
 #error "Platform not recognized"
 #endif

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

@@ -327,6 +327,19 @@ void config_default_tcp_user_timeout(bool enable, int timeout, bool is_client) {
 }
 
 // Set TCP_USER_TIMEOUT
+// As documented in
+// https://github.com/grpc/proposal/blob/master/A18-tcp-user-timeout.md, the
+// default values for TCP_USER_TIMEOUT are currently configured to be in line
+// with the default values of KEEPALIVE_TIMEOUT as proposed in
+// https://github.com/grpc/proposal/blob/master/A18-tcp-user-timeout.md. In
+// other words, by default, TCP_USER_TIMEOUT is disabled on clients (since
+// keepalive is disabled on clients by default), and enabled on servers. To
+// override the default settings of enabling/disabling TCP_USER_TIMEOUT, the
+// value of KEEPALIVE_TIME on channel args is used. If present, a value of
+// INT_MAX means that TCP_USER_TIMEOUT would be disabled, while any other value
+// would enable TCP_USER_TIMEOUT. If TCP_USER_TIMEOUT is enabled, the default
+// setting is 20 seconds (aligning with the default of KEEPALIVE_TIMEOUT). The
+// KEEPALIVE_TIMEOUT channel arg overrides the value used for TCP_USER_TIMEOUT.
 grpc_error_handle grpc_set_socket_tcp_user_timeout(
     int fd, const grpc_core::PosixTcpOptions& options, bool is_client) {
   // Use conditionally-important parameter to avoid warning

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

@@ -336,6 +336,7 @@ int64_t grpc_tcp_client_create_from_prepared_fd(
     err = connect(fd, reinterpret_cast<const grpc_sockaddr*>(addr->addr),
                   addr->len);
   } while (err < 0 && errno == EINTR);
+  int connect_errno = (err < 0) ? errno : 0;
 
   auto addr_uri = grpc_sockaddr_to_uri(addr);
   if (!addr_uri.ok()) {
@@ -347,7 +348,7 @@ int64_t grpc_tcp_client_create_from_prepared_fd(
   std::string name = absl::StrCat("tcp-client:", addr_uri.value());
   grpc_fd* fdobj = grpc_fd_create(fd, name.c_str(), true);
   int64_t connection_id = 0;
-  if (errno == EWOULDBLOCK || errno == EINPROGRESS) {
+  if (connect_errno == EWOULDBLOCK || connect_errno == EINPROGRESS) {
     // Connection is still in progress.
     connection_id = g_connection_id.fetch_add(1, std::memory_order_acq_rel);
   }
@@ -359,10 +360,10 @@ int64_t grpc_tcp_client_create_from_prepared_fd(
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, absl::OkStatus());
     return 0;
   }
-  if (errno != EWOULDBLOCK && errno != EINPROGRESS) {
+  if (connect_errno != EWOULDBLOCK && connect_errno != EINPROGRESS) {
     // Connection already failed. Return 0 to discourage any cancellation
     // attempts.
-    grpc_error_handle error = GRPC_OS_ERROR(errno, "connect");
+    grpc_error_handle error = GRPC_OS_ERROR(connect_errno, "connect");
     error = grpc_error_set_str(
         error, grpc_core::StatusStrProperty::kTargetAddress, addr_uri.value());
     grpc_fd_orphan(fdobj, nullptr, nullptr, "tcp_client_connect_error");

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

@@ -18,6 +18,12 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "absl/base/thread_annotations.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+
 #include <grpc/impl/grpc_types.h>
 
 #include "src/core/lib/iomgr/exec_ctx.h"
@@ -459,7 +465,7 @@ class TcpZerocopySendCtx {
   std::unordered_map<uint32_t, TcpZerocopySendRecord*> ctx_lookup_;
   bool memory_limited_ = false;
   bool is_in_write_ = false;
-  OMemState zcopy_enobuf_state_;
+  OMemState zcopy_enobuf_state_ = OMemState::OPEN;
 };
 
 }  // namespace grpc_core
@@ -479,10 +485,7 @@ struct grpc_tcp {
   grpc_endpoint base;
   grpc_fd* em_fd;
   int fd;
-  // Used by the endpoint read function to distinguish the very first read call
-  // from the rest
-  bool is_first_read;
-  bool has_posted_reclaimer ABSL_GUARDED_BY(read_mu) = false;
+  int inq;  // bytes pending on the socket from the last read.
   double target_length;
   double bytes_read_this_round;
   grpc_core::RefCount refcount;
@@ -490,15 +493,12 @@ struct grpc_tcp {
 
   int min_read_chunk_size;
   int max_read_chunk_size;
-  int set_rcvlowat = 0;
 
   // garbage after the last read
   grpc_slice_buffer last_read_buffer;
 
   grpc_core::Mutex read_mu;
   grpc_slice_buffer* incoming_buffer ABSL_GUARDED_BY(read_mu) = nullptr;
-  int inq;           // bytes pending on the socket from the last read.
-  bool inq_capable;  // cache whether kernel supports inq
 
   grpc_slice_buffer* outgoing_buffer;
   // byte within outgoing_buffer->slices[0] to write next
@@ -535,17 +535,26 @@ struct grpc_tcp {
   // options for collecting timestamps are set, and is incremented with each
   // byte sent.
   int bytes_counter;
-  bool socket_ts_enabled;  // True if timestamping options are set on the socket
-                           //
-  bool ts_capable;         // Cache whether we can set timestamping options
+
+  int min_progress_size;  // A hint from upper layers specifying the minimum
+                          // number of bytes that need to be read to make
+                          // meaningful progress
+
   gpr_atm stop_error_notification;  // Set to 1 if we do not want to be notified
                                     // on errors anymore
   TcpZerocopySendCtx tcp_zerocopy_send_ctx;
   TcpZerocopySendRecord* current_zerocopy_send = nullptr;
 
-  int min_progress_size;  // A hint from upper layers specifying the minimum
-                          // number of bytes that need to be read to make
-                          // meaningful progress
+  int set_rcvlowat = 0;
+
+  // Used by the endpoint read function to distinguish the very first read call
+  // from the rest
+  bool is_first_read;
+  bool has_posted_reclaimer ABSL_GUARDED_BY(read_mu) = false;
+  bool inq_capable;        // cache whether kernel supports inq
+  bool socket_ts_enabled;  // True if timestamping options are set on the socket
+                           //
+  bool ts_capable;         // Cache whether we can set timestamping options
 };
 
 struct backup_poller {
@@ -1935,7 +1944,7 @@ grpc_endpoint* grpc_tcp_create(grpc_fd* em_fd,
   tcp->fd = grpc_fd_wrapped_fd(em_fd);
   GPR_ASSERT(options.resource_quota != nullptr);
   tcp->memory_owner =
-      options.resource_quota->memory_quota()->CreateMemoryOwner(peer_string);
+      options.resource_quota->memory_quota()->CreateMemoryOwner();
   tcp->self_reservation = tcp->memory_owner.MakeReservation(sizeof(grpc_tcp));
   grpc_resolved_address resolved_local_addr;
   memset(&resolved_local_addr, 0, sizeof(resolved_local_addr));