grpc 1.72.0 → 1.74.0.pre2

data/include/grpc/event_engine/event_engine.h

@@ -16,16 +16,24 @@
 
 #include <grpc/event_engine/endpoint_config.h>
 #include <grpc/event_engine/extensible.h>
+#include <grpc/event_engine/internal/write_event.h>
 #include <grpc/event_engine/memory_allocator.h>
 #include <grpc/event_engine/port.h>
 #include <grpc/event_engine/slice_buffer.h>
 #include <grpc/support/port_platform.h>
 
+#include <bitset>
+#include <cstddef>
+#include <initializer_list>
+#include <memory>
+#include <optional>
+#include <utility>
 #include <vector>
 
 #include "absl/functional/any_invocable.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
+#include "absl/types/span.h"
 
 // TODO(vigneshbabu): Define the Endpoint::Write metrics collection system
 // TODO(hork): remove all references to the factory methods.
@@ -180,13 +188,26 @@ class EventEngine : public std::enable_shared_from_this<EventEngine>,
     /// EventEngine Endpoint Read API  call.
     ///
     /// Passed as argument to an Endpoint \a Read
-    struct ReadArgs {
+    class ReadArgs final {
+     public:
+      ReadArgs() = default;
+      ReadArgs(const ReadArgs&) = delete;
+      ReadArgs& operator=(const ReadArgs&) = delete;
+      ReadArgs(ReadArgs&&) = default;
+      ReadArgs& operator=(ReadArgs&&) = default;
+
       // A suggestion to the endpoint implementation to read at-least the
       // specified number of bytes over the network connection before marking
       // the endpoint read operation as complete. gRPC may use this argument
       // to minimize the number of endpoint read API calls over the lifetime
       // of a connection.
-      int64_t read_hint_bytes;
+      void set_read_hint_bytes(int64_t read_hint_bytes) {
+        read_hint_bytes_ = read_hint_bytes;
+      }
+      int64_t read_hint_bytes() const { return read_hint_bytes_; }
+
+     private:
+      int64_t read_hint_bytes_ = 1;
     };
     /// Reads data from the Endpoint.
     ///
@@ -212,21 +233,172 @@ class EventEngine : public std::enable_shared_from_this<EventEngine>,
     /// statuses to \a on_read. For example, callbacks might expect to receive
     /// CANCELLED on endpoint shutdown.
     virtual bool Read(absl::AnyInvocable<void(absl::Status)> on_read,
-                      SliceBuffer* buffer, const ReadArgs* args) = 0;
+                      SliceBuffer* buffer, ReadArgs args) = 0;
+    //// The set of write events that can be reported by an Endpoint.
+    using WriteEvent = ::grpc_event_engine::experimental::internal::WriteEvent;
+    /// An output WriteMetric consists of a key and a value.
+    /// The space of keys can be queried from the endpoint via the
+    /// \a AllWriteMetrics, \a GetMetricName and \a GetMetricKey APIs.
+    /// The value is an int64_t that is implementation-defined. Check with the
+    /// endpoint implementation documentation for the semantics of each metric.
+    struct WriteMetric {
+      size_t key;
+      int64_t value;
+    };
+    // It is the responsibility of the caller of WriteEventCallback to make sure
+    // that the corresponding endpoint is still valid. HINT: Do NOT offload
+    // callbacks onto the EventEngine or other threads.
+    using WriteEventCallback = absl::AnyInvocable<void(
+        WriteEvent, absl::Time, std::vector<WriteMetric>) const>;
+    // A bitmask of the events that the caller is interested in.
+    // Each bit corresponds to an entry in WriteEvent.
+    using WriteEventSet = std::bitset<static_cast<int>(WriteEvent::kCount)>;
+
+    // A set of metrics that the caller is interested in.
+    class MetricsSet {
+     public:
+      virtual ~MetricsSet() = default;
+
+      virtual bool IsSet(size_t key) const = 0;
+    };
+
+    // A sink to receive write events.
+    // The requested metrics are the keys of the metrics that the caller is
+    // interested in. The on_event callback will be called on each event
+    // requested.
+    class WriteEventSink final {
+     public:
+      WriteEventSink(std::shared_ptr<MetricsSet> requested_metrics,
+                     std::initializer_list<WriteEvent> requested_events,
+                     WriteEventCallback on_event)
+          : requested_metrics_(std::move(requested_metrics)),
+            on_event_(std::move(on_event)) {
+        for (auto event : requested_events) {
+          requested_events_mask_.set(static_cast<int>(event));
+        }
+      }
+
+      const std::shared_ptr<MetricsSet>& requested_metrics() const {
+        return requested_metrics_;
+      }
+
+      bool requested_event(WriteEvent event) const {
+        return requested_events_mask_.test(static_cast<int>(event));
+      }
+
+      WriteEventSet requested_events_mask() const {
+        return requested_events_mask_;
+      }
+
+      /// Takes the callback. Ownership is transferred. It is illegal to destroy
+      /// the endpoint before this callback is invoked.
+      WriteEventCallback TakeEventCallback() { return std::move(on_event_); }
+
+     private:
+      std::shared_ptr<MetricsSet> requested_metrics_;
+      WriteEventSet requested_events_mask_;
+      // The callback to be called on each event.
+      WriteEventCallback on_event_;
+    };
     /// A struct representing optional arguments that may be provided to an
     /// EventEngine Endpoint Write API call.
     ///
     /// Passed as argument to an Endpoint \a Write
-    struct WriteArgs {
+    class WriteArgs final {
+     public:
+      WriteArgs() = default;
+
+      ~WriteArgs();
+
+      WriteArgs(const WriteArgs&) = delete;
+      WriteArgs& operator=(const WriteArgs&) = delete;
+
+      WriteArgs(WriteArgs&& other) noexcept
+          : metrics_sink_(std::move(other.metrics_sink_)),
+            google_specific_(other.google_specific_),
+            max_frame_size_(other.max_frame_size_) {
+        other.google_specific_ = nullptr;
+      }
+
+      WriteArgs& operator=(WriteArgs&& other) noexcept {
+        if (this != &other) {
+          metrics_sink_ = std::move(other.metrics_sink_);
+          google_specific_ = other.google_specific_;
+          other.google_specific_ = nullptr;  // Nullify source
+          max_frame_size_ = other.max_frame_size_;
+        }
+        return *this;
+      }
+
+      // A sink to receive write events.
+      std::optional<WriteEventSink> TakeMetricsSink() {
+        auto sink = std::move(metrics_sink_);
+        metrics_sink_.reset();
+        return sink;
+      }
+
+      bool has_metrics_sink() const { return metrics_sink_.has_value(); }
+
+      void set_metrics_sink(WriteEventSink sink) {
+        metrics_sink_ = std::move(sink);
+      }
+
       // Represents private information that may be passed by gRPC for
       // select endpoints expected to be used only within google.
-      void* google_specific = nullptr;
+      // TODO(ctiller): Remove this method once all callers are migrated to
+      // metrics sink.
+      void* GetDeprecatedAndDiscouragedGoogleSpecificPointer() {
+        return google_specific_;
+      }
+
+      void* TakeDeprecatedAndDiscouragedGoogleSpecificPointer() {
+        return std::exchange(google_specific_, nullptr);
+      }
+
+      void SetDeprecatedAndDiscouragedGoogleSpecificPointer(void* pointer) {
+        google_specific_ = pointer;
+      }
+
       // A suggestion to the endpoint implementation to group data to be written
       // into frames of the specified max_frame_size. gRPC may use this
       // argument to dynamically control the max sizes of frames sent to a
       // receiver in response to high receiver memory pressure.
-      int64_t max_frame_size;
+      int64_t max_frame_size() const { return max_frame_size_; }
+
+      void set_max_frame_size(int64_t max_frame_size) {
+        max_frame_size_ = max_frame_size;
+      }
+
+     private:
+      std::optional<WriteEventSink> metrics_sink_;
+      void* google_specific_ = nullptr;
+      int64_t max_frame_size_ = 1024 * 1024;
     };
+
+    class TelemetryInfo {
+     public:
+      virtual ~TelemetryInfo() = default;
+
+      /// Returns the list of write metrics that the endpoint supports.
+      /// The keys are used to identify the metrics in the GetMetricName and
+      /// GetMetricKey APIs. The current value of the metric can be queried by
+      /// adding a WriteEventSink to the WriteArgs of a Write call.
+      virtual std::vector<size_t> AllWriteMetrics() const = 0;
+      /// Returns the name of the write metric with the given key.
+      /// If the key is not found, returns std::nullopt.
+      virtual std::optional<absl::string_view> GetMetricName(
+          size_t key) const = 0;
+      /// Returns the key of the write metric with the given name.
+      /// If the name is not found, returns std::nullopt.
+      virtual std::optional<size_t> GetMetricKey(
+          absl::string_view name) const = 0;
+      /// Returns a MetricsSet with all the keys from \a keys set.
+      virtual std::shared_ptr<MetricsSet> GetMetricsSet(
+          absl::Span<const size_t> keys) const = 0;
+      /// Returns a MetricsSet with all supported keys set.
+      virtual std::shared_ptr<MetricsSet> GetFullMetricsSet() const = 0;
+    };
+
     /// Writes data out on the connection.
     ///
     /// If the write succeeds immediately, it returns true and the
@@ -248,11 +420,13 @@ class EventEngine : public std::enable_shared_from_this<EventEngine>,
     /// statuses to \a on_writable. For example, callbacks might expect to
     /// receive CANCELLED on endpoint shutdown.
     virtual bool Write(absl::AnyInvocable<void(absl::Status)> on_writable,
-                       SliceBuffer* data, const WriteArgs* args) = 0;
+                       SliceBuffer* data, WriteArgs args) = 0;
     /// Returns an address in the format described in DNSResolver. The returned
     /// values are expected to remain valid for the life of the Endpoint.
     virtual const ResolvedAddress& GetPeerAddress() const = 0;
     virtual const ResolvedAddress& GetLocalAddress() const = 0;
+
+    virtual std::shared_ptr<TelemetryInfo> GetTelemetryInfo() const = 0;
   };
 
   /// Called when a new connection is established.
@@ -334,7 +508,7 @@ class EventEngine : public std::enable_shared_from_this<EventEngine>,
   /// when the object is destroyed and all pending callbacks will be called
   /// shortly. If cancellation races with request completion, implementations
   /// may choose to either cancel or satisfy the request.
-  class DNSResolver {
+  class DNSResolver : public Extensible {
    public:
     /// Optional configuration for DNSResolvers.
     struct ResolverOptions {

data/include/grpc/event_engine/internal/write_event.h

@@ -0,0 +1,34 @@
+// Copyright 2022 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_EVENT_ENGINE_INTERNAL_WRITE_EVENT_H
+#define GRPC_EVENT_ENGINE_INTERNAL_WRITE_EVENT_H
+
+namespace grpc_event_engine::experimental::internal {
+
+// Use of this enum via this name is internal to gRPC.
+// API users should get this enumeration via the
+// EventEngine::Endpoint::WriteEvent.
+enum class WriteEvent {
+  kSendMsg,
+  kScheduled,
+  kSent,
+  kAcked,
+  kClosed,
+  kCount  // Must be last.
+};
+
+}  // namespace grpc_event_engine::experimental::internal
+
+#endif  // GRPC_EVENT_ENGINE_INTERNAL_WRITE_EVENT_H

data/include/grpc/grpc_posix.h

@@ -56,6 +56,25 @@ GRPCAPI void grpc_server_add_channel_from_fd(grpc_server* server, int fd,
 
 #ifdef __cplusplus
 }
-#endif
+
+namespace grpc_core::experimental {
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * This function creates a gRPC channel using a raw file descriptor
+ * that represents an open socket. This API supports both secure and insecure
+ * channel credentials.
+ *
+ * \param fd The file descriptor representing the connection.
+ * \param creds The channel credentials used to secure the connection.
+ * \param args Optional channel arguments to configure the channel behavior.
+ */
+grpc_channel* CreateChannelFromFd(int fd, grpc_channel_credentials* creds,
+                                  const grpc_channel_args* args);
+
+}  // namespace grpc_core::experimental
+
+#endif  // __cplusplus
 
 #endif /* GRPC_GRPC_POSIX_H */

data/include/grpc/impl/channel_arg_names.h

@@ -51,11 +51,13 @@
  * server will close the connection. Int valued, milliseconds. INT_MAX means
  * unlimited. Defaults to INT_MAX. */
 #define GRPC_ARG_MAX_CONNECTION_IDLE_MS "grpc.max_connection_idle_ms"
-/** Maximum time that a channel may exist. Int valued, milliseconds.
- * INT_MAX means unlimited. Defaults to INT_MAX. */
+/** Maximum amount of time in milliseconds that a connection may exist before it
+ * will be gracefully shut down. Refer
+ * https://github.com/grpc/proposal/blob/master/A9-server-side-conn-mgt.md for
+ * more details. Int valued, defaults to INT_MAX (disabled). */
 #define GRPC_ARG_MAX_CONNECTION_AGE_MS "grpc.max_connection_age_ms"
-/** Grace period after the channel reaches its max age. Int valued,
-   milliseconds. INT_MAX means unlimited. Defaults to INT_MAX. */
+/** Grace period in milliseconds after connection reaches its max age for
+ * outstanding RPCs to complete. Int valued, defaults to INT_MAX (disabled). */
 #define GRPC_ARG_MAX_CONNECTION_AGE_GRACE_MS "grpc.max_connection_age_grace_ms"
 /** Timeout after the last RPC finishes on the client channel at which the
  * channel goes back into IDLE state. Int valued, milliseconds. INT_MAX means
@@ -121,10 +123,8 @@
 /** Channel arg to override the http2 :scheme header. String valued. */
 #define GRPC_ARG_HTTP2_SCHEME "grpc.http2_scheme"
 /** How many pings can the client send before needing to send a data/header
-   frame? (0 indicates that an infinite number of pings can be sent without
-   sending a data frame or header frame).
-   If experiment "max_pings_wo_data_throttle" is enabled, instead of pings being
-   completely blocked, they are throttled.
+   frame, without being throttled? (0 indicates that an infinite number of pings
+  can be sent without sending a data frame or header frame).
   * Integer valued. Defaults to 2. */
 #define GRPC_ARG_HTTP2_MAX_PINGS_WITHOUT_DATA \
   "grpc.http2.max_pings_without_data"
@@ -168,13 +168,19 @@
 /** Secondary user agent: goes at the end of the user-agent metadata
     sent on each request. A string. */
 #define GRPC_ARG_SECONDARY_USER_AGENT_STRING "grpc.secondary_user_agent"
-/** The minimum time between subsequent connection attempts, in ms. Defaults to
- * 20 seconds. */
+/** The minimum time between subsequent connection attempts, in ms. Refer to
+ * MIN_CONNECT_TIMEOUT from
+ * https://github.com/grpc/grpc/blob/master/doc/connection-backoff.md. Defaults
+ * to 20 seconds. */
 #define GRPC_ARG_MIN_RECONNECT_BACKOFF_MS "grpc.min_reconnect_backoff_ms"
-/** The maximum time between subsequent connection attempts, in ms. Defaults to
- * 120 seconds. */
+/** The maximum time between subsequent connection attempts, in ms. Refer to
+ * MAX_BACKOFF from
+ * https://github.com/grpc/grpc/blob/master/doc/connection-backoff.md. Defaults
+ * to 120 seconds.  */
 #define GRPC_ARG_MAX_RECONNECT_BACKOFF_MS "grpc.max_reconnect_backoff_ms"
-/** The time between the first and second connection attempts, in ms. Defaults
+/** The time between the first and second connection attempts, in ms. Refer to
+ * INITIAL_BACKOFF from
+ * https://github.com/grpc/grpc/blob/master/doc/connection-backoff.md. Defaults
  * to 1 second. */
 #define GRPC_ARG_INITIAL_RECONNECT_BACKOFF_MS \
   "grpc.initial_reconnect_backoff_ms"

data/include/grpc/impl/compression_types.h

@@ -41,8 +41,9 @@ extern "C" {
  * Its value is an int from the \a grpc_compression_algorithm enum. */
 #define GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM \
   "grpc.default_compression_algorithm"
-/** Default compression level for the channel.
- * Its value is an int from the \a grpc_compression_level enum. */
+/** Set the default compression level for the channel.
+ * Valid values are defined by the enum type grpc_compression_level, defaults to
+ * GRPC_COMPRESS_LEVEL_NONE. */
 #define GRPC_COMPRESSION_CHANNEL_DEFAULT_LEVEL "grpc.default_compression_level"
 /** Compression algorithms supported by the channel.
  * Its value is a bitset (an int). Bits correspond to algorithms in \a

data/include/grpc/impl/slice_type.h

@@ -73,7 +73,7 @@ struct grpc_slice {
   } data;
 };
 
-#define GRPC_SLICE_BUFFER_INLINE_ELEMENTS 6
+#define GRPC_SLICE_BUFFER_INLINE_ELEMENTS 3
 
 /** Represents an expandable array of slices, to be interpreted as a
    single item. */

data/include/grpc/module.modulemap

@@ -6,6 +6,7 @@ header "byte_buffer.h"
   header "byte_buffer_reader.h"
   header "census.h"
   header "compression.h"
+  header "create_channel_from_endpoint.h"
   header "credentials.h"
   header "fork.h"
   header "grpc.h"

data/include/grpc/support/json.h

@@ -22,6 +22,7 @@
 
 #include <map>
 #include <string>
+#include <type_traits>
 #include <utility>
 #include <variant>
 #include <vector>
@@ -46,6 +47,30 @@ class Json {
     kArray,    // Use array() for payload.
   };
 
+  template <typename Sink>
+  friend void AbslStringify(Sink& sink, Type type) {
+    switch (type) {
+      case Type::kNull:
+        sink.Append("null");
+        break;
+      case Type::kBoolean:
+        sink.Append("boolean");
+        break;
+      case Type::kNumber:
+        sink.Append("number");
+        break;
+      case Type::kString:
+        sink.Append("string");
+        break;
+      case Type::kObject:
+        sink.Append("object");
+        break;
+      case Type::kArray:
+        sink.Append("array");
+        break;
+    }
+  }
+
   using Object = std::map<std::string, Json>;
   using Array = std::vector<Json>;
 
@@ -72,27 +97,8 @@ class Json {
     json.value_ = NumberValue{std::move(str)};
     return json;
   }
-  static Json FromNumber(int32_t value) {
-    Json json;
-    json.value_ = NumberValue{absl::StrCat(value)};
-    return json;
-  }
-  static Json FromNumber(uint32_t value) {
-    Json json;
-    json.value_ = NumberValue{absl::StrCat(value)};
-    return json;
-  }
-  static Json FromNumber(int64_t value) {
-    Json json;
-    json.value_ = NumberValue{absl::StrCat(value)};
-    return json;
-  }
-  static Json FromNumber(uint64_t value) {
-    Json json;
-    json.value_ = NumberValue{absl::StrCat(value)};
-    return json;
-  }
-  static Json FromNumber(double value) {
+  template <typename T>
+  static std::enable_if_t<std::is_arithmetic_v<T>, Json> FromNumber(T value) {
     Json json;
     json.value_ = NumberValue{absl::StrCat(value)};
     return json;

data/include/grpc/support/port_platform.h

@@ -26,17 +26,20 @@
 #define GRPC_DEPRECATED(reason)
 #endif  // __cplusplus >= 201402L
 
+#ifndef GPR_DISABLE_ABSEIL_SYNC
 /*
  * Defines GPR_ABSEIL_SYNC to use synchronization features from Abseil
+ *
+ * You can opt for gRPC's native synchronization by enabling
+ * GPR_DISABLE_ABSEIL_SYNC. However, this flag is temporary and will be
+ * removed once the Abseil synchronization is stabilized.
+ * If you encounter any issues with this feature, please report them
+ * by filing a bug at https://github.com/grpc/grpc.
  */
 #ifndef GPR_ABSEIL_SYNC
-#if defined(__APPLE__)
-// This is disabled on Apple platforms because macos/grpc_basictests_c_cpp
-// fails with this. https://github.com/grpc/grpc/issues/23661
-#else
 #define GPR_ABSEIL_SYNC 1
-#endif
 #endif  // GPR_ABSEIL_SYNC
+#endif  // GPR_DISABLE_ABSEIL_SYNC
 
 /* Get windows.h included everywhere (we need it) */
 #if defined(_WIN64) || defined(WIN64) || defined(_WIN32) || defined(WIN32)

data/src/core/call/call_filters.h

@@ -1316,7 +1316,7 @@ template <typename T>
 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline OperationExecutor<
     T>::~OperationExecutor() {
   if (promise_data_ != nullptr) {
-    ops_->early_destroy(promise_data_);
+    if (ops_ != end_ops_) ops_->early_destroy(promise_data_);
     gpr_free_aligned(promise_data_);
   }
 }
@@ -1349,7 +1349,10 @@ OperationExecutor<T>::InitStep(T input, void* call_data) {
         ops_->promise_init(promise_data_, Offset(call_data, ops_->call_offset),
                            ops_->channel_data, std::move(input));
     if (auto* r = p.value_if_ready()) {
-      if (r->ok == nullptr) return std::move(*r);
+      if (r->ok == nullptr) {
+        ops_ = end_ops_;
+        return std::move(*r);
+      }
       input = std::move(r->ok);
       ++ops_;
       continue;
@@ -1443,20 +1446,20 @@ constexpr bool MethodHasChannelAccess<R (T::*)()> = false;
 template <typename T, typename R, typename A, typename C>
 constexpr bool MethodHasChannelAccess<R (T::*)(A, C)> = true;
 
-template <auto... Ts>
-constexpr bool AnyMethodHasChannelAccess =
-    (MethodHasChannelAccess<decltype(Ts)> || ...);
+template <typename... Ts>
+constexpr bool AnyMethodHasChannelAccess = (MethodHasChannelAccess<Ts> || ...);
 
 // Composite for a given channel type to determine if any of its interceptors
 // fall into this category: later code should use this.
 template <typename Derived>
 inline constexpr bool CallHasChannelAccess() {
-  return AnyMethodHasChannelAccess<&Derived::Call::OnClientInitialMetadata,
-                                   &Derived::Call::OnClientToServerMessage,
-                                   &Derived::Call::OnServerInitialMetadata,
-                                   &Derived::Call::OnServerToClientMessage,
-                                   &Derived::Call::OnServerTrailingMetadata,
-                                   &Derived::Call::OnFinalize>;
+  return AnyMethodHasChannelAccess<
+      decltype(&Derived::Call::OnClientInitialMetadata),
+      decltype(&Derived::Call::OnClientToServerMessage),
+      decltype(&Derived::Call::OnServerInitialMetadata),
+      decltype(&Derived::Call::OnServerToClientMessage),
+      decltype(&Derived::Call::OnServerTrailingMetadata),
+      decltype(&Derived::Call::OnFinalize)>;
 }
 }  // namespace filters_detail
 
@@ -1667,7 +1670,9 @@ class CallFilters {
         }
         return FinishStep(executor_.Start(
             &(stack_current_->stack->data_.*layout),
-            std::move(filters_->*input_location), filters_->call_data_));
+            std::move(filters_->*input_location),
+            filters_detail::Offset(filters_->call_data_,
+                                   stack_current_->call_data_offset)));
       } else {
         return FinishStep(executor_.Step(filters_->call_data_));
       }
@@ -1684,9 +1689,10 @@ class CallFilters {
           (filters_->call_state_.*on_done)();
           return ValueOrFailure<Output>{std::move(r->ok)};
         }
-        return FinishStep(
-            executor_.Start(&(stack_current_->stack->data_.*layout),
-                            std::move(r->ok), filters_->call_data_));
+        return FinishStep(executor_.Start(
+            &(stack_current_->stack->data_.*layout), std::move(r->ok),
+            filters_detail::Offset(filters_->call_data_,
+                                   stack_current_->call_data_offset)));
       }
       (filters_->call_state_.*on_done)();
       filters_->PushServerTrailingMetadata(std::move(r->error));
@@ -1724,7 +1730,9 @@ class CallFilters {
         }
         return FinishStep(executor_.Start(
             &(stack_current_->stack->data_.*layout),
-            std::move(filters_->*input_location), filters_->call_data_));
+            std::move(filters_->*input_location),
+            filters_detail::Offset(filters_->call_data_,
+                                   stack_current_->call_data_offset)));
       } else {
         return FinishStep(executor_.Step(filters_->call_data_));
       }
@@ -1739,9 +1747,10 @@ class CallFilters {
         if (stack_current_ == stack_end_) {
           return NextMsg{std::move(r->ok), &filters_->call_state_};
         }
-        return FinishStep(
-            executor_.Start(&(stack_current_->stack->data_.*layout),
-                            std::move(r->ok), filters_->call_data_));
+        return FinishStep(executor_.Start(
+            &(stack_current_->stack->data_.*layout), std::move(r->ok),
+            filters_detail::Offset(filters_->call_data_,
+                                   stack_current_->call_data_offset)));
       }
       (filters_->call_state_.*on_done)();
       filters_->PushServerTrailingMetadata(std::move(r->error));

data/src/core/call/call_spine.h

@@ -144,6 +144,8 @@ class CallSpine final : public Party {
   template <typename StatusType>
   void CancelIfFailed(const StatusType& r) {
     if (!IsStatusOk(r)) {
+      GRPC_TRACE_LOG(call_state, INFO)
+          << "[call_state] spine " << this << " fails: " << r;
       Cancel();
     }
   }

data/src/core/call/interception_chain.h

@@ -163,11 +163,8 @@ class InterceptionChainBuilder final {
                                         RefCountedPtr<CallDestination>>;
 
   explicit InterceptionChainBuilder(ChannelArgs args,
-                                    const Blackboard* old_blackboard = nullptr,
-                                    Blackboard* new_blackboard = nullptr)
-      : args_(std::move(args)),
-        old_blackboard_(old_blackboard),
-        new_blackboard_(new_blackboard) {}
+                                    const Blackboard* blackboard = nullptr)
+      : args_(std::move(args)), blackboard_(blackboard) {}
 
   // Add a filter with a `Call` class as an inner member.
   // Call class must be one compatible with the filters described in
@@ -176,8 +173,8 @@ class InterceptionChainBuilder final {
   absl::enable_if_t<sizeof(typename T::Call) != 0, InterceptionChainBuilder&>
   Add() {
     if (!status_.ok()) return *this;
-    auto filter = T::Create(args_, {FilterInstanceId(FilterTypeId<T>()),
-                                    old_blackboard_, new_blackboard_});
+    auto filter =
+        T::Create(args_, {FilterInstanceId(FilterTypeId<T>()), blackboard_});
     if (!filter.ok()) {
       status_ = filter.status();
       return *this;
@@ -193,8 +190,8 @@ class InterceptionChainBuilder final {
   absl::enable_if_t<std::is_base_of<Interceptor, T>::value,
                     InterceptionChainBuilder&>
   Add() {
-    AddInterceptor(T::Create(args_, {FilterInstanceId(FilterTypeId<T>()),
-                                     old_blackboard_, new_blackboard_}));
+    AddInterceptor(
+        T::Create(args_, {FilterInstanceId(FilterTypeId<T>()), blackboard_}));
     return *this;
   };
 
@@ -273,8 +270,7 @@ class InterceptionChainBuilder final {
   absl::Status status_;
   std::map<size_t, size_t> filter_type_counts_;
   static std::atomic<size_t> next_filter_id_;
-  const Blackboard* old_blackboard_ = nullptr;
-  Blackboard* new_blackboard_ = nullptr;
+  const Blackboard* blackboard_ = nullptr;
 };
 
 }  // namespace grpc_core