grpc 1.81.1 → 1.82.0.pre2

data/src/core/filter/composite/composite_filter.cc

@@ -102,10 +102,17 @@ CompositeFilter::CompositeFilter(const ChannelArgs& args,
     if (action.type() != ExecuteFilterAction::Type()) return;
     const auto& execute_filter_action =
         DownCast<const ExecuteFilterAction&>(action);
-    InterceptionChainBuilder builder(args, filter_args.blackboard());
+    auto it = config_->merged_config_map.find(&action);
+    GRPC_CHECK(it != config_->merged_config_map.end());
+    auto& merged_configs = it->second;
+    GRPC_CHECK_EQ(merged_configs.size(),
+                  execute_filter_action.filter_chain().size());
+    InterceptionChainBuilder builder(args);
     InterceptionChainBuilderWrapper builder_wrapper(builder);
-    for (const auto& [filter_impl, filter_config] :
-         execute_filter_action.filter_chain()) {
+    for (size_t i = 0; i < merged_configs.size(); ++i) {
+      const auto* filter_impl =
+          execute_filter_action.filter_chain()[i].filter_impl;
+      const auto& filter_config = merged_configs[i];
       // TODO(roth): Currently, this code assumes that it is always
       // running on the client side, so we'll need to remove this
       // assumption in order to make this filter work on the server

data/src/core/filter/composite/composite_filter.h

@@ -116,7 +116,17 @@ class CompositeFilter final : public V3InterceptorToV2Bridge<CompositeFilter> {
       return matcher->ToString();
     }
 
-    std::unique_ptr<XdsMatcher> matcher;
+    std::shared_ptr<const XdsMatcher> matcher;
+
+    // For each action, contains the list of merged filter configs to
+    // use.  This is basically the same as the filter configs in the
+    // matcher actions, except that the configs may include fields set
+    // from the blackboard.
+    // Note: This is not actually part of the identity of the config
+    // (i.e., does not matter for Equals()).
+    absl::flat_hash_map<const XdsMatcher::Action*,
+                        std::vector<RefCountedPtr<const FilterConfig>>>
+        merged_config_map;
   };
 
   static const grpc_channel_filter kFilterVtable;

data/src/core/filter/filter_args.h

@@ -17,7 +17,6 @@
 
 #include <memory>
 
-#include "src/core/filter/blackboard.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/util/match.h"
 #include "src/core/util/ref_counted.h"
@@ -58,12 +57,10 @@ class FilterArgs {
              grpc_channel_element* channel_element,
              size_t (*channel_stack_filter_instance_number)(
                  grpc_channel_stack*, grpc_channel_element*),
-             RefCountedPtr<const FilterConfig> config = nullptr,
-             const Blackboard* blackboard = nullptr)
+             RefCountedPtr<const FilterConfig> config = nullptr)
       : impl_(ChannelStackBased{channel_stack, channel_element,
                                 channel_stack_filter_instance_number}),
-        config_(std::move(config)),
-        blackboard_(blackboard) {}
+        config_(std::move(config)) {}
   // While we're moving to call-v3 we need to have access to
   // grpc_channel_stack & friends here. That means that we can't rely on this
   // type signature from interception_chain.h, which means that we need a way
@@ -71,11 +68,8 @@ class FilterArgs {
   // TODO(ctiller): remove this once we're fully on call-v3
   // NOLINTNEXTLINE(google-explicit-constructor)
   FilterArgs(size_t instance_id,
-             RefCountedPtr<const FilterConfig> config = nullptr,
-             const Blackboard* blackboard = nullptr)
-      : impl_(V3Based{instance_id}),
-        config_(std::move(config)),
-        blackboard_(blackboard) {}
+             RefCountedPtr<const FilterConfig> config = nullptr)
+      : impl_(V3Based{instance_id}), config_(std::move(config)) {}
 
   ABSL_DEPRECATED("Direct access to channel stack is deprecated")
   grpc_channel_stack* channel_stack() const {
@@ -103,17 +97,6 @@ class FilterArgs {
 
   RefCountedPtr<const FilterConfig> config() const { return config_; }
 
-  // Gets the filter state associated with a particular type and key.
-  template <typename T>
-  RefCountedPtr<T> GetState(const std::string& key) const {
-    if (blackboard_ == nullptr) return nullptr;
-    return blackboard_->Get<T>(key);
-  }
-
-  // Do not use unless you know what you're doing -- prefer to use
-  // GetState() instead!
-  const Blackboard* blackboard() const { return blackboard_; }
-
  private:
   friend class ChannelFilter;
 
@@ -132,7 +115,6 @@ class FilterArgs {
   Impl impl_;
 
   const RefCountedPtr<const FilterConfig> config_;
-  const Blackboard* blackboard_ = nullptr;
 };
 
 }  // namespace grpc_core

data/src/core/handshaker/handshaker.cc

@@ -139,9 +139,14 @@ void HandshakeManager::Shutdown(absl::Status error) {
     is_shutdown_ = true;
     // Shutdown the handshaker that's currently in progress, if any.
     if (index_ > 0) {
+      auto& handshaker = *handshakers_[index_ - 1];
       GRPC_CHANNELZ_LOG(args_.trace_node)
-          << "Shutting down handshaker at index " << (index_ - 1);
-      handshakers_[index_ - 1]->Shutdown(std::move(error));
+          << "Shutting down handshaker " << handshaker.name() << " at index "
+          << (index_ - 1);
+      if (IsVerboseChannelzConnectionLoggingEnabled()) {
+        args_.trace_node.Commit();
+      }
+      handshaker.Shutdown(std::move(error));
     }
   }
 }
@@ -187,6 +192,9 @@ void HandshakeManager::CallNextHandshakerLocked(absl::Status error) {
   auto handshaker = handshakers_[index_];
   GRPC_CHANNELZ_LOG(args_.trace_node)
       << " calling handshaker " << handshaker->name() << " at index " << index_;
+  if (IsVerboseChannelzConnectionLoggingEnabled()) {
+    args_.trace_node.Commit();
+  }
   ++index_;
   handshaker->DoHandshake(&args_, [self = Ref()](absl::Status error) mutable {
     MutexLock lock(&self->mu_);

data/src/core/handshaker/security/secure_endpoint.cc

@@ -39,6 +39,8 @@
 #include <vector>
 
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/event_engine/extensions/receive_coalescing_extension.h"
+#include "src/core/lib/event_engine/query_extensions.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/endpoint.h"
@@ -575,6 +577,17 @@ class FrameProtector : public RefCounted<FrameProtector> {
     }
   }
 
+  // Resets the read staging buffer.
+  // Per the contract of EnableRpcReceiveCoalescing(), this is only
+  // called when there are no outstanding Read() operations on the endpoint.
+  // Therefore, any valid plaintext has already been fully delivered, and
+  // read_staging_buffer_ contains only unused, leftover memory capacity.
+  void ResetReadStagingBuffer() {
+    MutexLock lock(&read_mu_);
+    CSliceUnref(read_staging_buffer_);
+    read_staging_buffer_ = grpc_empty_slice();
+  }
+
  private:
   struct tsi_frame_protector* const protector_;
   struct tsi_zero_copy_grpc_protector* const zero_copy_protector_;
@@ -821,7 +834,8 @@ static const grpc_endpoint_vtable vtable = {endpoint_read,
 namespace grpc_event_engine::experimental {
 namespace {
 
-class SecureEndpoint final : public EventEngine::Endpoint {
+class SecureEndpoint final : public EventEngine::Endpoint,
+                             public ReceiveCoalescingExtension {
  public:
   SecureEndpoint(
       std::unique_ptr<grpc_event_engine::experimental::EventEngine::Endpoint>
@@ -855,9 +869,24 @@ class SecureEndpoint final : public EventEngine::Endpoint {
   }
 
   void* QueryExtension(absl::string_view id) override {
+    if (id == ReceiveCoalescingExtension::EndpointExtensionName()) {
+      return static_cast<ReceiveCoalescingExtension*>(this);
+    }
     return impl_->QueryExtension(id);
   }
 
+  void EnableRpcReceiveCoalescing() override {
+    impl_->EnableRpcReceiveCoalescing();
+  }
+
+  void DisableRpcReceiveCoalescing() override {
+    impl_->DisableRpcReceiveCoalescing();
+  }
+
+  void EnforceRxMemoryAlignment() override {
+    impl_->EnforceRxMemoryAlignment();
+  }
+
   std::shared_ptr<TelemetryInfo> GetTelemetryInfo() const override {
     return std::make_shared<Impl::TelemetryInfo>(impl_->GetTelemetryInfo());
   }
@@ -940,11 +969,20 @@ class SecureEndpoint final : public EventEngine::Endpoint {
       // TODO(aananthv): Evaluate if we need to add a channel_arg to enable this
       // selectively.
       if (grpc_core::IsSecureEndpointReadCoalescingEnabled()) {
+        {
+          // This mutex should not have any contention since we can only have
+          // one outstanding Read() at a time.
+          grpc_core::MutexLock lock(&read_settings_mu_);
+          if (rpc_receive_coalescing_enabled_) {
+            // TODO(aananthv): Make required_read_bytes_ a separate field in
+            // ReadArgs to avoid confusion between min_progress_size and
+            // read_hint_bytes, especially if we enable coalescing by default.
+            required_read_bytes_ = std::max<int64_t>(0, args.read_hint_bytes());
+          } else {
+            required_read_bytes_ = 0;
+          }
+        }
         read_buffer_ = buffer;
-        // TODO(aananthv): Make required_read_bytes_ a separate field in
-        // ReadArgs to avoid confusion between min_progress_size and
-        // read_hint_bytes, especially if we enable coalescing by default.
-        required_read_bytes_ = std::max<int64_t>(0, args.read_hint_bytes());
         read_args_ = args;
         frame_protector_.BeginRead(buffer->c_slice_buffer(),
                                    required_read_bytes_);
@@ -1052,6 +1090,33 @@ class SecureEndpoint final : public EventEngine::Endpoint {
       return wrapped_ep_->GetLocalAddress();
     }
 
+    void EnableRpcReceiveCoalescing() {
+      {
+        grpc_core::MutexLock lock(&read_settings_mu_);
+        rpc_receive_coalescing_enabled_ = true;
+      }
+      frame_protector_.ResetReadStagingBuffer();
+      // We do not need to enable this in the underlying endpoint since we only
+      // benefit from coalescing the user-facing buffer.
+      // TODO(aananthv): Should we disable it explicitly?
+    }
+
+    void DisableRpcReceiveCoalescing() {
+      {
+        grpc_core::MutexLock lock(&read_settings_mu_);
+        rpc_receive_coalescing_enabled_ = false;
+      }
+    }
+
+    void EnforceRxMemoryAlignment() {
+      auto* ext = grpc_event_engine::experimental::QueryExtension<
+          grpc_event_engine::experimental::ReceiveCoalescingExtension>(
+          wrapped_ep_.get());
+      if (ext != nullptr) {
+        ext->EnforceRxMemoryAlignment();
+      }
+    }
+
     void* QueryExtension(absl::string_view id) {
       return wrapped_ep_->QueryExtension(id);
     }
@@ -1306,6 +1371,9 @@ class SecureEndpoint final : public EventEngine::Endpoint {
     const size_t large_read_threshold_;
     const size_t large_write_threshold_;
     const size_t max_buffered_writes_;
+    grpc_core::Mutex read_settings_mu_;
+    bool rpc_receive_coalescing_enabled_ ABSL_GUARDED_BY(read_settings_mu_) =
+        false;
   };
 
   grpc_core::RefCountedPtr<Impl> impl_;

data/src/core/lib/channel/channel_args.h

@@ -55,6 +55,8 @@
 
 namespace grpc_core {
 
+class Arena;
+
 // Define a traits object for vtable lookup - allows us to integrate with
 // existing code easily (just define the trait!) and allows some magic in
 // ChannelArgs to automatically derive a vtable from a T*.
@@ -88,8 +90,7 @@ struct IsRawPointerTagged {
   static constexpr bool kValue = false;
 };
 template <typename T>
-struct IsRawPointerTagged<T,
-                          absl::void_t<typename T::RawPointerChannelArgTag>> {
+struct IsRawPointerTagged<T, std::void_t<typename T::RawPointerChannelArgTag>> {
   static constexpr bool kValue = true;
 };
 
@@ -114,8 +115,8 @@ template <typename T, typename = void>
 struct has_channel_args_compare : std::false_type {};
 template <typename T>
 struct has_channel_args_compare<
-    T, absl::void_t<decltype(T::ChannelArgsCompare(std::declval<const T*>(),
-                                                   std::declval<const T*>()))>>
+    T, std::void_t<decltype(T::ChannelArgsCompare(std::declval<const T*>(),
+                                                  std::declval<const T*>()))>>
     : std::true_type {};
 }  // namespace channel_args_detail
 
@@ -193,7 +194,7 @@ struct ChannelArgTypeTraits<
 // ownership*.
 template <typename T>
 struct ChannelArgTypeTraits<T,
-                            absl::void_t<typename T::RawPointerChannelArgTag>> {
+                            std::void_t<typename T::RawPointerChannelArgTag>> {
   static void* TakeUnownedPointer(T* p) { return p; }
   static const grpc_arg_pointer_vtable* VTable() {
     static const grpc_arg_pointer_vtable tbl = {
@@ -216,7 +217,7 @@ struct ChannelArgPointerShouldBeConst {
 
 template <typename T>
 struct ChannelArgPointerShouldBeConst<
-    T, absl::void_t<decltype(T::ChannelArgUseConstPtr())>> {
+    T, std::void_t<decltype(T::ChannelArgUseConstPtr())>> {
   static constexpr bool kValue = T::ChannelArgUseConstPtr();
 };
 
@@ -299,6 +300,11 @@ template <typename T>
 struct ChannelArgNameTraits<std::shared_ptr<T>> {
   static absl::string_view ChannelArgName() { return T::ChannelArgName(); }
 };
+template <>
+struct ChannelArgTypeTraits<Arena> {
+  static const grpc_arg_pointer_vtable* VTable();
+  static void* TakeUnownedPointer(Arena* p) { return p; }
+};
 // Specialization for the EventEngine
 template <>
 struct ChannelArgNameTraits<grpc_event_engine::experimental::EventEngine> {

data/src/core/lib/channel/channel_stack.cc

@@ -115,7 +115,7 @@ grpc_error_handle grpc_channel_stack_init(
     int initial_refs, grpc_iomgr_cb_func destroy, void* destroy_arg,
     std::vector<grpc_core::FilterAndConfig> filters,
     const grpc_core::ChannelArgs& channel_args, const char* name,
-    grpc_channel_stack* stack, const grpc_core::Blackboard* blackboard) {
+    grpc_channel_stack* stack) {
   if (GRPC_TRACE_FLAG_ENABLED(channel_stack)) {
     LOG(INFO) << "CHANNEL_STACK: init " << name;
     for (const auto& [filter, _] : filters) {
@@ -144,7 +144,6 @@ grpc_error_handle grpc_channel_stack_init(
                                              sizeof(grpc_channel_element));
 
   // init per-filter data
-  args.blackboard = blackboard;
   grpc_error_handle first_error;
   for (i = 0; i < filters.size(); ++i) {
     args.channel_stack = stack;

data/src/core/lib/channel/channel_stack.h

@@ -68,17 +68,12 @@
 #include "src/core/util/time_precise.h"
 #include "src/core/util/unique_type_name.h"
 
-namespace grpc_core {
-class Blackboard;
-}  // namespace grpc_core
-
 struct grpc_channel_element_args {
   grpc_channel_stack* channel_stack;
   grpc_core::ChannelArgs channel_args;
   int is_first;
   int is_last;
   grpc_core::RefCountedPtr<const grpc_core::FilterConfig> config;
-  const grpc_core::Blackboard* blackboard;
 };
 struct grpc_call_element_args {
   grpc_call_stack* call_stack;
@@ -276,8 +271,7 @@ grpc_error_handle grpc_channel_stack_init(
     int initial_refs, grpc_iomgr_cb_func destroy, void* destroy_arg,
     std::vector<grpc_core::FilterAndConfig> filters,
     const grpc_core::ChannelArgs& args, const char* name,
-    grpc_channel_stack* stack,
-    const grpc_core::Blackboard* blackboard = nullptr);
+    grpc_channel_stack* stack);
 // Destroy a channel stack
 void grpc_channel_stack_destroy(grpc_channel_stack* stack);
 

data/src/core/lib/channel/channel_stack_builder_impl.cc

@@ -70,7 +70,7 @@ ChannelStackBuilderImpl::Build() {
         grpc_channel_stack_destroy(stk);
         gpr_free(stk);
       },
-      channel_stack, stack, channel_args(), name(), channel_stack, blackboard_);
+      channel_stack, stack, channel_args(), name(), channel_stack);
 
   if (!error.ok()) {
     grpc_channel_stack_destroy(channel_stack);

data/src/core/lib/channel/channel_stack_builder_impl.h

@@ -24,8 +24,6 @@
 
 namespace grpc_core {
 
-class Blackboard;
-
 // Build a channel stack.
 // Allows interested parties to add filters to the stack, and to query an
 // in-progress build.
@@ -35,17 +33,12 @@ class ChannelStackBuilderImpl final : public ChannelStackBuilder {
  public:
   using ChannelStackBuilder::ChannelStackBuilder;
 
-  void SetBlackboard(const Blackboard* blackboard) { blackboard_ = blackboard; }
-
   // Build the channel stack.
   // After success, *result holds the new channel stack,
   // prefix_bytes are allocated before the channel stack,
   // initial_refs, destroy, destroy_arg are as per grpc_channel_stack_init
   // On failure, *result is nullptr.
   absl::StatusOr<RefCountedPtr<grpc_channel_stack>> Build() override;
-
- private:
-  const Blackboard* blackboard_ = nullptr;
 };
 
 }  // namespace grpc_core

data/src/core/lib/channel/promise_based_filter.cc

@@ -26,6 +26,7 @@
 #include "src/core/call/metadata.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/promise/seq.h"
 #include "src/core/lib/slice/slice.h"
@@ -495,6 +496,14 @@ void BaseCallData::SendMessage::Done(const ServerMetadata& metadata,
     case State::kPushedToPipe:
       push_.reset();
       next_.reset();
+      // Ensure captured transport batches are released if the call terminates
+      // while a message is in-flight. This prevents deadlocks where the
+      // transport never receives the batch, leaving the RPC hanging for
+      // metadata.
+      if (IsV2NonOwningWakerImplementationEnabled()) {
+        GRPC_DCHECK(batch_.is_captured());
+        batch_.CancelWith(StatusFromMetadata(metadata), flusher);
+      }
       state_ = State::kCancelledButNotYetPolled;
       if (base_->is_current()) base_->ForceImmediateRepoll();
       break;
@@ -1164,7 +1173,10 @@ class ClientCallData::PollContext {
                       std::exchange(
                           self_->recv_initial_metadata_->original_on_ready,
                           nullptr),
-                      absl::CancelledError(),
+                      IsV2NonOwningWakerImplementationEnabled() &&
+                              !StatusFromMetadata(*md).ok()
+                          ? StatusFromMetadata(*md)
+                          : absl::CancelledError(),
                       "wake_inside_combiner:recv_initial_metadata_ready");
               }
             }

data/src/core/lib/channel/promise_based_filter.h

@@ -38,7 +38,6 @@
 #include "src/core/call/message.h"
 #include "src/core/call/metadata.h"
 #include "src/core/call/metadata_batch.h"
-#include "src/core/filter/blackboard.h"
 #include "src/core/filter/filter_args.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
@@ -163,7 +162,7 @@ struct HasAsyncErrorInterceptor<Promise (T::*)(A...),
   static constexpr bool value = true;
 };
 
-// For the list case we do two interceptors to avoid amiguities with the single
+// For the list case we do two interceptors to avoid ambiguities with the single
 // argument forms above.
 template <typename... Interceptors>
 inline constexpr bool HasAnyAsyncErrorInterceptor(Interceptors...) {
@@ -1175,7 +1174,7 @@ MakeFilterCall(Derived* derived) {
 //   useful for cases where the exact metadata returned needs to be customized.
 // It's also acceptable to return a promise that resolves to the
 // relevant return type listed above.
-// Finally, OnFinalize can be added to intecept call finalization.
+// Finally, OnFinalize can be added to intercept call finalization.
 // It must have one of the signatures:
 // - static inline const NoInterceptor OnFinalize:
 //   the filter does not intercept call finalization.
@@ -1423,7 +1422,7 @@ class V3InterceptorToV2Bridge : public ChannelFilter, public Interceptor {
                         });
                   });
               // In the v3 handler's activity, pull client initial metadata.
-              // Use an inter-acitivity latch to get it back to the v2
+              // Use an inter-activity latch to get it back to the v2
               // activity.
               handler.SpawnGuarded(
                   "pull_client_initial_metadata",
@@ -2268,7 +2267,7 @@ struct ChannelFilterWithFlagsMethods {
         F::Create(args->channel_args,
                   ChannelFilter::Args(args->channel_stack, elem,
                                       grpc_channel_stack_filter_instance_number,
-                                      args->config, args->blackboard));
+                                      args->config));
     if (!status.ok()) {
       new (elem->channel_data) F*(nullptr);
       return absl_status_to_grpc_error(status.status());

data/src/core/lib/event_engine/extensions/chaotic_good_extension.h

@@ -42,19 +42,6 @@ class ChaoticGoodExtension {
   /// one provided to it through the channel args. It is safe to call this
   /// only when there are no outstanding Reads on the Endpoint.
   virtual void UseMemoryQuota(grpc_core::MemoryQuotaRefPtr mem_quota) = 0;
-
-  /// Forces the endpoint to receive rpcs in one contiguous block of memory.
-  /// It is safe to call this only when there are no outstanding Reads on
-  /// the Endpoint.
-  virtual void EnableRpcReceiveCoalescing() = 0;
-
-  /// Disables rpc receive coalescing until it is explicitly enabled again.
-  /// It is safe to call this only when there are no outstanding Reads on
-  /// the Endpoint.
-  virtual void DisableRpcReceiveCoalescing() = 0;
-  /// If invoked, the endpoint tries to preserve proper order and alignment of
-  /// any memory that maybe shared across reads.
-  virtual void EnforceRxMemoryAlignment() = 0;
 };
 
 }  // namespace grpc_event_engine::experimental

data/src/core/lib/event_engine/extensions/receive_coalescing_extension.h

@@ -0,0 +1,48 @@
+// Copyright 2026 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_EXTENSIONS_RECEIVE_COALESCING_EXTENSION_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_RECEIVE_COALESCING_EXTENSION_H
+
+#include "absl/strings/string_view.h"
+
+namespace grpc_event_engine::experimental {
+
+/// An Endpoint extension class that will be supported by EventEngine endpoints
+/// which need to work with receive coalescing.
+class ReceiveCoalescingExtension {
+ public:
+  virtual ~ReceiveCoalescingExtension() = default;
+  static absl::string_view EndpointExtensionName() {
+    return "io.grpc.event_engine.extension.receive_coalescing_extension";
+  }
+
+  /// Forces the endpoint to receive rpcs in one contiguous block of memory.
+  /// It is safe to call this only when there are no outstanding Reads on
+  /// the Endpoint.
+  virtual void EnableRpcReceiveCoalescing() = 0;
+
+  /// Disables rpc receive coalescing until it is explicitly enabled again.
+  /// It is safe to call this only when there are no outstanding Reads on
+  /// the Endpoint.
+  virtual void DisableRpcReceiveCoalescing() = 0;
+
+  /// If invoked, the endpoint tries to preserve proper order and alignment of
+  /// any memory that maybe shared across reads.
+  virtual void EnforceRxMemoryAlignment() = 0;
+};
+
+}  // namespace grpc_event_engine::experimental
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_RECEIVE_COALESCING_EXTENSION_H

data/src/core/lib/event_engine/posix.h

@@ -22,6 +22,7 @@
 
 #include "src/core/lib/event_engine/extensions/can_track_errors.h"
 #include "src/core/lib/event_engine/extensions/chaotic_good_extension.h"
+#include "src/core/lib/event_engine/extensions/receive_coalescing_extension.h"
 #include "src/core/lib/event_engine/extensions/supports_fd.h"
 #include "src/core/lib/event_engine/query_extensions.h"
 
@@ -31,6 +32,7 @@ namespace grpc_event_engine::experimental {
 /// may implement to support additional chaotic good related functionality.
 class PosixEndpointWithChaoticGoodSupport
     : public ExtendedType<EventEngine::Endpoint, ChaoticGoodExtension,
+                          ReceiveCoalescingExtension,
                           EndpointSupportsFdExtension,
                           EndpointCanTrackErrorsExtension> {};
 

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

@@ -95,7 +95,8 @@ NativePosixDNSResolver::NativePosixDNSResolver(
 void NativePosixDNSResolver::LookupHostname(
     EventEngine::DNSResolver::LookupHostnameCallback on_resolved,
     absl::string_view name, absl::string_view default_port) {
-  event_engine_->Run([name = std::string(name), default_port,
+  event_engine_->Run([name = std::string(name),
+                      default_port = std::string(default_port),
                       on_resolved = std::move(on_resolved)]() mutable {
     on_resolved(LookupHostnameBlocking(name, default_port));
   });

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

@@ -29,6 +29,7 @@
 #include <memory>
 #include <optional>
 #include <string>
+#include <utility>
 
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/event_engine/posix_engine/event_poller.h"
@@ -44,7 +45,6 @@
 #include "src/core/util/load_file.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/status_helper.h"
-#include "src/core/util/strerror.h"
 #include "src/core/util/sync.h"
 #include "absl/functional/any_invocable.h"
 #include "absl/log/log.h"
@@ -136,10 +136,11 @@ uint64_t ParseUlimitMemLockFromFile(std::string file_name) {
     return 0;
   }
   // Find position of next newline after prefix.
-  size_t end = file_contents.find(start, '\n');
+  size_t end = file_contents.find('\n', start);
   // Extract substring between prefix and next newline.
+  size_t value_start = start + kHardMemlockPrefix.length() + 1;
   auto memlock_value_string = file_contents.substr(
-      start + kHardMemlockPrefix.length() + 1, end - start);
+      value_start, end == std::string::npos ? end : end - value_start);
   rtrim(memlock_value_string);
   if (memlock_value_string == "unlimited" ||
       memlock_value_string == "infinity") {
@@ -370,8 +371,8 @@ bool PosixEndpointImpl::TcpDoRead(absl::Status& status) {
       } else if (read_bytes == 0) {
         status = TcpAnnotateError(absl::InternalError("Socket closed"));
       } else {
-        status = TcpAnnotateError(absl::InternalError(
-            absl::StrCat("recvmsg:", grpc_core::StrError(errno))));
+        status = TcpAnnotateError(
+            absl::InternalError(absl::StrCat("recvmsg:", res.StrError())));
       }
       return true;
     }
@@ -892,7 +893,7 @@ bool PosixEndpointImpl::WriteWithTimestamps(struct msghdr* msg,
   traced_buffers_.AddNewEntry(
       static_cast<uint32_t>(bytes_counter_ + sending_length),
       &poller_->posix_interface(), handle_->WrappedFd(),
-      std::move(outgoing_buffer_write_event_sink_).value());
+      std::move(*outgoing_buffer_write_event_sink_));
   outgoing_buffer_write_event_sink_.reset();
 
   // If there was an error on sendmsg the logic in tcp_flush will handle it.
@@ -940,6 +941,7 @@ void PosixEndpointImpl::UnrefMaybePutZerocopySendRecord(
 void PosixEndpointImpl::TcpShutdownTracedBufferList() {
   if (outgoing_buffer_write_event_sink_.has_value()) {
     traced_buffers_.Shutdown(std::move(outgoing_buffer_write_event_sink_));
+    outgoing_buffer_write_event_sink_.reset();
   }
 }
 
@@ -1134,6 +1136,7 @@ bool PosixEndpointImpl::TcpFlush(absl::Status& status) {
     }
 
     GRPC_CHECK_EQ(outgoing_byte_idx_, 0u);
+    GRPC_CHECK_LE((static_cast<size_t>(*send_result)), sending_length);
     bytes_counter_ += *send_result;
     trailing = sending_length - static_cast<size_t>(*send_result);
     while (trailing > 0) {
@@ -1270,7 +1273,7 @@ void PosixEndpointImpl::MaybeShutdown(
   Unref();
 }
 
-PosixEndpointImpl ::~PosixEndpointImpl() {
+PosixEndpointImpl::~PosixEndpointImpl() {
   FileDescriptor release_fd;
   handle_->OrphanHandle(on_done_,
                         on_release_fd_ == nullptr ? nullptr : &release_fd, "");
@@ -1327,7 +1330,7 @@ PosixEndpointImpl::PosixEndpointImpl(EventHandle* handle,
                  << "ulimit value is not set. Use ulimit -l <value> to set its "
                  << "value.";
     } else {
-      if (posix_interface.SetSockOpt(fd, SOL_SOCKET, SO_ZEROCOPY, 1).ok()) {
+      if (!posix_interface.SetSockOpt(fd, SOL_SOCKET, SO_ZEROCOPY, 1).ok()) {
         zerocopy_enabled = false;
         LOG(ERROR) << "Failed to set zerocopy options on the socket.";
       }