grpc 1.81.1 → 1.83.0

data/include/grpc/grpc.h

@@ -446,19 +446,18 @@ typedef struct {
 
 typedef struct grpc_server_config_fetcher grpc_server_config_fetcher;
 
+/** EXPERIMENTAL.  Channel arg vtable for server config fetcher. */
+GRPCAPI const grpc_arg_pointer_vtable* grpc_server_config_fetcher_arg_vtable(
+    void);
+
 /** EXPERIMENTAL.  Creates an xDS config fetcher. */
 GRPCAPI grpc_server_config_fetcher* grpc_server_config_fetcher_xds_create(
     grpc_server_xds_status_notifier notifier, const grpc_channel_args* args);
 
-/** EXPERIMENTAL.  Destroys a config fetcher. */
-GRPCAPI void grpc_server_config_fetcher_destroy(
+/** EXPERIMENTAL.  Unrefs a config fetcher. */
+GRPCAPI void grpc_server_config_fetcher_unref(
     grpc_server_config_fetcher* config_fetcher);
 
-/** EXPERIMENTAL.  Sets the server's config fetcher.  Takes ownership.
-    Must be called before adding ports */
-GRPCAPI void grpc_server_set_config_fetcher(
-    grpc_server* server, grpc_server_config_fetcher* config_fetcher);
-
 /** Add a HTTP2 over an encrypted link over tcp listener.
    Returns bound port number on success, 0 on failure.
    REQUIRES: server not started */

data/include/grpc/grpc_audit_logging.h

@@ -78,11 +78,11 @@ class AuditLoggerFactory {
   virtual ~AuditLoggerFactory() = default;
   virtual absl::string_view name() const = 0;
 
-  virtual absl::StatusOr<std::unique_ptr<Config>> ParseAuditLoggerConfig(
+  virtual absl::StatusOr<std::shared_ptr<const Config>> ParseAuditLoggerConfig(
       const Json& json) = 0;
 
   virtual std::unique_ptr<AuditLogger> CreateAuditLogger(
-      std::unique_ptr<AuditLoggerFactory::Config>) = 0;
+      std::shared_ptr<const Config> config) = 0;
 };
 
 // Registers an audit logger factory. This should only be called during

data/include/grpc/grpc_security_constants.h

@@ -155,6 +155,8 @@ typedef enum {
   GRPC_TLS_GROUP_X25519,
   /** X25519_MLKEM768 hybrid key exchange. Post-quantum cryptography. */
   GRPC_TLS_GROUP_X25519_MLKEM768,
+  /** secp384r1 ECDH key exchange. */
+  GRPC_TLS_GROUP_SECP384R1,
 } grpc_tls_key_exchange_group;
 
 #ifdef __cplusplus

data/include/grpc/impl/channel_arg_names.h

@@ -35,7 +35,7 @@
     Boolean valued. Defaults to false. */
 #define GRPC_ARG_MINIMAL_STACK "grpc.minimal_stack"
 /** Maximum number of concurrent incoming streams to allow on a http2
-    connection. Int valued. Deafult to -1(indicating no explicit limit).*/
+    connection. Int valued. Default to -1(indicating no explicit limit).*/
 #define GRPC_ARG_MAX_CONCURRENT_STREAMS "grpc.max_concurrent_streams"
 /** Maximum message length that the channel can receive. Int valued, bytes.
     -1 means unlimited. Defaults to 4MB(4*1024*1024 bytes). -1 means unlimited.
@@ -120,6 +120,22 @@
     before the request is cancelled */
 #define GRPC_ARG_SERVER_MAX_UNREQUESTED_TIME_IN_SERVER_SECONDS \
   "grpc.server_max_unrequested_time_in_server"
+/** The soft limit on the number of pending requests in the server. Int valued.
+ *  If the number of pending queued requests exceeds this soft limit, then the
+ *  server will start to probabilistically reject new incoming requests up until
+ *  the hard limit. Defaults to 1000.
+ *  Note: It is not recommended to change this value unless the operational
+ *  implications are fully understood.
+ */
+#define GRPC_ARG_SERVER_MAX_PENDING_REQUESTS "grpc.server.max_pending_requests"
+/** The hard limit on the number of pending requests in the server. Int valued.
+ *  If the number of pending queued requests reaches this hard limit, all new
+ *  incoming requests will be rejected. Defaults to 3000.
+ *  Note: It is not recommended to change this value unless the operational
+ *  implications are fully understood.
+ */
+#define GRPC_ARG_SERVER_MAX_PENDING_REQUESTS_HARD_LIMIT \
+  "grpc.server.max_pending_requests_hard_limit"
 /** 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
@@ -441,5 +457,14 @@
 /** \} */
 /** If non-zero, enable TCP tracing and stats collection. */
 #define GRPC_ARG_TCP_TRACING_ENABLED "grpc.tcp_tracing_enabled"
+/* Enable tracing full buffer payloads for TCP telemetry. */
+#define GRPC_ARG_TCP_TRACE_FULL_BUFFER "grpc.experimental.tcp_trace_full_buffer"
+/** Server config fetcher. */
+#define GRPC_ARG_SERVER_CONFIG_FETCHER "grpc.server_config_fetcher"
+/** Set the maximum size of a security frame that can be received on a HTTP2
+ * Connection. Check file core/ext/transport/chttp2/transport/frame.cc for
+ * details on the Security Frame.
+ */
+#define GRPC_ARG_MAX_SECURITY_FRAME_SIZE "grpc.http2.max_security_frame_size"
 
 #endif /* GRPC_IMPL_CHANNEL_ARG_NAMES_H */

data/src/core/call/call_filters.h

@@ -91,7 +91,7 @@
 // It's also acceptable to return a promise that resolves to the
 // relevant return type listed above.
 //
-// OnFinalize is added to intecept call finalization.
+// OnFinalize is added to intercept call finalization.
 // It must have one of the signatures:
 // - static inline const NoInterceptor OnFinalize:
 //   the filter does not intercept call finalization.
@@ -276,7 +276,7 @@ struct CallConstructor {
 
 template <typename FilterType>
 struct CallConstructor<FilterType,
-                       absl::void_t<decltype(typename FilterType::Call(
+                       std::void_t<decltype(typename FilterType::Call(
                            static_cast<FilterType*>(nullptr)))>> {
   static void Construct(void* call_data, FilterType* channel) {
     new (call_data) typename FilterType::Call(channel);
@@ -1976,7 +1976,11 @@ class CallFilters {
   // Returns a promise that resolves to a StatusFlag indicating success
   StatusFlag PushServerInitialMetadata(ServerMetadataHandle md) {
     push_server_initial_metadata_ = std::move(md);
-    return call_state_.PushServerInitialMetadata();
+    auto flag = call_state_.PushServerInitialMetadata();
+    if (!IsStatusOk(flag)) {
+      push_server_initial_metadata_ = nullptr;
+    }
+    return flag;
   }
   // Client: Fetch server initial metadata
   // Returns a promise that resolves to ValueOrFailure<ServerMetadataHandle>
@@ -2015,7 +2019,13 @@ class CallFilters {
     GRPC_DCHECK_NE(message.get(), nullptr);
     GRPC_DCHECK_EQ(push_client_to_server_message_.get(), nullptr);
     push_client_to_server_message_ = std::move(message);
-    return [this]() { return call_state_.PollPushClientToServerMessage(); };
+    return Map([this]() { return call_state_.PollPushClientToServerMessage(); },
+               [this](StatusFlag r) {
+                 if (!IsStatusOk(r)) {
+                   push_client_to_server_message_ = nullptr;
+                 }
+                 return r;
+               });
   }
   // Client: Indicate that no more messages will be sent
   void FinishClientToServerSends() { call_state_.ClientToServerHalfClose(); }
@@ -2047,7 +2057,13 @@ class CallFilters {
   GRPC_MUST_USE_RESULT auto PushServerToClientMessage(MessageHandle message) {
     call_state_.BeginPushServerToClientMessage();
     push_server_to_client_message_ = std::move(message);
-    return [this]() { return call_state_.PollPushServerToClientMessage(); };
+    return Map([this]() { return call_state_.PollPushServerToClientMessage(); },
+               [this](StatusFlag r) {
+                 if (!IsStatusOk(r)) {
+                   push_server_to_client_message_ = nullptr;
+                 }
+                 return r;
+               });
   }
   // Server: Fetch server to client message
   // Returns a promise that resolves to ServerToClientNextMessage

data/src/core/call/call_spine.h

@@ -33,6 +33,7 @@
 #include "src/core/lib/promise/pipe.h"
 #include "src/core/lib/promise/prioritized_race.h"
 #include "src/core/lib/promise/promise.h"
+#include "src/core/lib/promise/race.h"
 #include "src/core/lib/promise/status_flag.h"
 #include "src/core/lib/promise/try_seq.h"
 #include "src/core/util/dual_ref_counted.h"
@@ -223,10 +224,9 @@ class CallSpine final : public Party, public channelz::DataSource {
   template <typename Promise>
   auto UntilCallCompletes(Promise&& promise) {
     using Result = PromiseResult<std::decay_t<Promise>>;
-    return PrioritizedRace(std::forward<Promise>(promise),
-                           Map(WasCancelled(), [](bool) {
-                             return FailureStatusCast<Result>(Failure{});
-                           }));
+    return Race(Map(WasCancelled(),
+                    [](bool) { return FailureStatusCast<Result>(Failure{}); }),
+                std::forward<Promise>(promise));
   }
 
   template <typename PromiseFactory>

data/src/core/call/client_call.cc

@@ -257,7 +257,7 @@ Party::WakeupHold ClientCall::StartCall(
     const grpc_op& send_initial_metadata_op) {
   GRPC_LATENT_SEE_SCOPE("ClientCall::StartCall");
   auto cur_state = call_state_.load(std::memory_order_acquire);
-  // TODO(akshitpatel): [PH2][P3]: Might need to invoke
+  // TODO(akshitpatel): [PH2][P1]: Might need to invoke
   // PrepareApplicationMetadata here.
   CToMetadata(send_initial_metadata_op.data.send_initial_metadata.metadata,
               send_initial_metadata_op.data.send_initial_metadata.count,
@@ -443,7 +443,7 @@ void ClientCall::OnReceivedStatus(ServerMetadataHandle server_trailing_metadata,
                           .value_or(GRPC_STATUS_UNKNOWN);
   *out_status = status;
   Slice message_slice;
-  if (!IsErrorFlattenEnabled() || status != GRPC_STATUS_OK) {
+  if (status != GRPC_STATUS_OK) {
     if (Slice* message =
             server_trailing_metadata->get_pointer(GrpcMessageMetadata())) {
       message_slice = message->Ref();

data/src/core/call/interception_chain.h

@@ -29,7 +29,6 @@
 
 namespace grpc_core {
 
-class Blackboard;
 class InterceptionChainBuilder;
 
 // One hijacked call. Using this we can get access to the CallHandler for the
@@ -174,9 +173,8 @@ class InterceptionChainBuilder final {
   using FinalDestination = std::variant<RefCountedPtr<UnstartedCallDestination>,
                                         RefCountedPtr<CallDestination>>;
 
-  explicit InterceptionChainBuilder(ChannelArgs args,
-                                    const Blackboard* blackboard = nullptr)
-      : args_(std::move(args)), blackboard_(blackboard) {}
+  explicit InterceptionChainBuilder(ChannelArgs args)
+      : args_(std::move(args)) {}
 
   // Add a filter with a `Call` class as an inner member.
   // Call class must be one compatible with the filters described in
@@ -185,8 +183,8 @@ class InterceptionChainBuilder final {
   absl::enable_if_t<sizeof(typename T::Call) != 0, InterceptionChainBuilder&>
   Add(RefCountedPtr<const FilterConfig> config) {
     if (!status_.ok()) return *this;
-    auto filter = T::Create(args_, {FilterInstanceId(FilterTypeId<T>()),
-                                    std::move(config), blackboard_});
+    auto filter = T::Create(
+        args_, {FilterInstanceId(FilterTypeId<T>()), std::move(config)});
     if (!filter.ok()) {
       status_ = filter.status();
       return *this;
@@ -202,8 +200,8 @@ class InterceptionChainBuilder final {
   absl::enable_if_t<std::is_base_of<Interceptor, T>::value,
                     InterceptionChainBuilder&>
   Add(RefCountedPtr<const FilterConfig> config) {
-    AddInterceptor(T::Create(args_, {FilterInstanceId(FilterTypeId<T>()),
-                                     std::move(config), blackboard_}));
+    AddInterceptor(T::Create(
+        args_, {FilterInstanceId(FilterTypeId<T>()), std::move(config)}));
     return *this;
   };
 
@@ -282,7 +280,6 @@ 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* blackboard_ = nullptr;
 };
 
 }  // namespace grpc_core

data/src/core/call/metadata.cc

@@ -37,10 +37,15 @@ ServerMetadataHandle ServerMetadataFromStatus(const absl::Status& status) {
 absl::Status ServerMetadataToStatus(ServerMetadata& md) {
   const auto grpc_status =
       md.get(GrpcStatusMetadata()).value_or(GRPC_STATUS_UNKNOWN);
+  if (grpc_status == GRPC_STATUS_OK) {
+    return absl::OkStatus();
+  }
   const auto* error_slice = md.get_pointer(GrpcMessageMetadata());
+  absl::string_view message = error_slice != nullptr
+                                  ? error_slice->as_string_view()
+                                  : absl::string_view();
   return grpc_error_set_int(
-      absl::Status(static_cast<absl::StatusCode>(grpc_status),
-                   error_slice->as_string_view()),
+      absl::Status(static_cast<absl::StatusCode>(grpc_status), message),
       StatusIntProperty::kRpcStatus, grpc_status);
 }
 

data/src/core/call/metadata.h

@@ -229,7 +229,7 @@ struct StatusCastImpl<ServerMetadataHandle, absl::Status&> {
 template <typename T>
 struct StatusCastImpl<
     ServerMetadataHandle, T,
-    absl::void_t<decltype(&StatusCastImpl<absl::Status, T>::Cast)>> {
+    std::void_t<decltype(&StatusCastImpl<absl::Status, T>::Cast)>> {
   static ServerMetadataHandle Cast(const T& m) {
     return ServerMetadataFromStatus(StatusCast<absl::Status>(m));
   }

data/src/core/call/metadata_batch.cc

@@ -90,7 +90,7 @@ void DebugStringBuilder::AddAfterRedaction(absl::string_view key,
   } else {
     // If the type of metadata is not in the allow list, we want to prevent it
     // from getting logged. Custom metadata types may have sensitive information
-    // that should never be logged. Programatically, we have no way to know
+    // that should never be logged. Programmatically, we have no way to know
     // which data is sensitive and which is not. So we redact all values which
     // are not in the allow list.
     Add(key,

data/src/core/call/metadata_batch.h

@@ -706,7 +706,7 @@ struct IsEncodableTrait {
 };
 
 template <typename Trait>
-struct IsEncodableTrait<Trait, absl::void_t<decltype(Trait::key())>> {
+struct IsEncodableTrait<Trait, std::void_t<decltype(Trait::key())>> {
   static const bool value = true;
 };
 
@@ -885,6 +885,22 @@ class GetStringValueHelper {
     return value->as_string_view();
   }
 
+  template <typename Trait>
+  GPR_ATTRIBUTE_NOINLINE absl::enable_if_t<
+      Trait::kRepeatable == true &&
+          std::is_same<Slice, typename Trait::ValueType>::value,
+      std::optional<absl::string_view>>
+  Found(Trait) {
+    const auto* value = container_->get_pointer(Trait());
+    if (value == nullptr) return std::nullopt;
+    backing_->clear();
+    for (const auto& v : *value) {
+      if (!backing_->empty()) backing_->push_back(',');
+      backing_->append(v.as_string_view());
+    }
+    return *backing_;
+  }
+
   template <typename Trait>
   GPR_ATTRIBUTE_NOINLINE absl::enable_if_t<
       Trait::kRepeatable == true &&

data/src/core/call/parsed_metadata.h

@@ -365,8 +365,13 @@ ParsedMetadata<MetadataContainer>::SliceTraitVTable() {
       metadata_detail::DestroySliceValue,
       // set
       [](const Buffer& value, MetadataContainer* map) {
-        metadata_detail::SetSliceValue<Which::MementoToValue>(
-            map->GetOrCreatePointer(Which()), value);
+        if constexpr (Which::kRepeatable) {
+          map->GetOrCreatePointer(Which())->emplace_back(
+              Which::MementoToValue(metadata_detail::SliceFromBuffer(value)));
+        } else {
+          metadata_detail::SetSliceValue<Which::MementoToValue>(
+              map->GetOrCreatePointer(Which()), value);
+        }
       },
       // with_new_value
       WithNewValueSetSlice<Which::ParseMemento>,

data/src/core/call/server_call.cc

@@ -101,6 +101,18 @@ grpc_call_error ValidateServerBatch(const grpc_op* ops, size_t nops) {
 
 }  // namespace
 
+absl::string_view ServerCall::GetServerAuthority() const {
+  GRPC_DCHECK(client_initial_metadata_stored_ != nullptr);
+  if (client_initial_metadata_stored_ != nullptr) {
+    const Slice* authority_metadata =
+        client_initial_metadata_stored_->get_pointer(HttpAuthorityMetadata());
+    if (authority_metadata != nullptr) {
+      return authority_metadata->as_string_view();
+    }
+  }
+  return "";
+}
+
 grpc_call_error ServerCall::StartBatch(const grpc_op* ops, size_t nops,
                                        void* notify_tag,
                                        bool is_notify_tag_closure) {
@@ -244,15 +256,15 @@ void ServerCall::CommitBatch(const grpc_op* ops, size_t nops, void* notify_tag,
 grpc_call* MakeServerCall(CallHandler call_handler,
                           ClientMetadataHandle client_initial_metadata,
                           ServerInterface* server, grpc_completion_queue* cq,
-                          grpc_metadata_array* publish_initial_metadata) {
-  PublishMetadataArray(client_initial_metadata.get(), publish_initial_metadata,
-                       false);
+                          grpc_metadata_array* publish_initial_metadata,
+                          RefCountedPtr<Arena> parent_arena) {
   // TODO(ctiller): ideally we'd put this in the arena with the CallHandler,
   // but there's an ownership problem: CallHandler owns the arena, and so would
   // get destroyed before the base class Call destructor runs, leading to
   // UB/crash. Investigate another path.
   return (new ServerCall(std::move(client_initial_metadata),
-                         std::move(call_handler), server, cq))
+                         std::move(call_handler), server, cq,
+                         publish_initial_metadata, std::move(parent_arena)))
       ->c_ptr();
 }
 

data/src/core/call/server_call.h

@@ -62,7 +62,9 @@ class ServerCall final : public Call, public DualRefCounted<ServerCall> {
  public:
   ServerCall(ClientMetadataHandle client_initial_metadata,
              CallHandler call_handler, ServerInterface* server,
-             grpc_completion_queue* cq)
+             grpc_completion_queue* cq,
+             grpc_metadata_array* publish_initial_metadata,
+             RefCountedPtr<Arena> parent_arena = nullptr)
       : Call(false,
              client_initial_metadata->get(GrpcTimeoutMetadata())
                  .value_or(Timestamp::InfFuture()),
@@ -72,6 +74,14 @@ class ServerCall final : public Call, public DualRefCounted<ServerCall> {
         cq_(cq),
         server_(server) {
     global_stats().IncrementServerCallsCreated();
+    if (parent_arena != nullptr) {
+      auto* parent_ctx = arena()->New<ParentCallContext>();
+      parent_ctx->arena = std::move(parent_arena);
+      arena()->SetContext<ParentCallContext>(parent_ctx);
+    }
+    ProcessIncomingInitialMetadata(*client_initial_metadata_stored_);
+    PublishMetadataArray(client_initial_metadata_stored_.get(),
+                         publish_initial_metadata, false);
     SourceConstructed();
   }
 
@@ -86,9 +96,7 @@ class ServerCall final : public Call, public DualRefCounted<ServerCall> {
   bool is_trailers_only() const override {
     Crash("is_trailers_only not implemented for server calls");
   }
-  absl::string_view GetServerAuthority() const override {
-    Crash("unimplemented");
-  }
+  absl::string_view GetServerAuthority() const override;
   grpc_call_error StartBatch(const grpc_op* ops, size_t nops, void* notify_tag,
                              bool is_notify_tag_closure) override;
   void FailBatchImmediately(void* notify_tag, bool is_notify_tag_closure,
@@ -168,7 +176,8 @@ class ServerCall final : public Call, public DualRefCounted<ServerCall> {
 grpc_call* MakeServerCall(CallHandler call_handler,
                           ClientMetadataHandle client_initial_metadata,
                           ServerInterface* server, grpc_completion_queue* cq,
-                          grpc_metadata_array* publish_initial_metadata);
+                          grpc_metadata_array* publish_initial_metadata,
+                          RefCountedPtr<Arena> parent_arena);
 
 }  // namespace grpc_core
 

data/src/core/call/status_util.cc

@@ -115,8 +115,6 @@ bool grpc_status_code_from_int(int status_int, grpc_status_code* status) {
 
 namespace grpc_core {
 
-namespace internal {
-
 std::string StatusCodeSet::ToString() const {
   std::vector<absl::string_view> codes;
   for (size_t i = 0; i < GPR_ARRAY_SIZE(g_status_string_entries); ++i) {
@@ -127,8 +125,6 @@ std::string StatusCodeSet::ToString() const {
   return absl::StrCat("{", absl::StrJoin(codes, ","), "}");
 }
 
-}  // namespace internal
-
 absl::Status MaybeRewriteIllegalStatusCode(absl::Status status,
                                            absl::string_view source) {
   switch (status.code()) {

data/src/core/call/status_util.h

@@ -41,7 +41,6 @@ const char* grpc_status_code_to_string(grpc_status_code status);
 bool grpc_status_code_from_int(int status_int, grpc_status_code* status);
 
 namespace grpc_core {
-namespace internal {
 
 /// A set of grpc_status_code values.
 class StatusCodeSet {
@@ -67,8 +66,6 @@ class StatusCodeSet {
   int status_code_mask_ = 0;  // A bitfield of status codes in the set.
 };
 
-}  // namespace internal
-
 // Optionally rewrites a status as per
 // https://github.com/grpc/proposal/blob/master/A54-restrict-control-plane-status-codes.md.
 // The source parameter indicates where the status came from.

data/src/core/channelz/channel_trace.cc

@@ -269,7 +269,9 @@ void ChannelTrace::RenderEntry(const Entry& entry,
     RenderEntry(entries_[id], child, arena);
     size_t length;
     auto* bytes = grpc_channelz_v2_TraceEvent_serialize(child, arena, &length);
-    auto* data = grpc_channelz_v2_Data_new(arena);
+    // Allocate and attach the Data object directly to the trace_event
+    auto* data = grpc_channelz_v2_TraceEvent_add_data(trace_event, arena);
+    // Set the name and value of the fields in the Data object
     grpc_channelz_v2_Data_set_name(data, StdStringToUpbString("child_trace"));
     auto* any = grpc_channelz_v2_Data_mutable_value(data, arena);
     google_protobuf_Any_set_value(

data/src/core/client_channel/backup_poller.cc

@@ -65,11 +65,6 @@ void grpc_client_channel_global_init_backup_polling() {
   g_backup_polling_disabled = grpc_core::IsEventEngineClientEnabled() &&
                               grpc_core::IsEventEngineListenerEnabled() &&
                               grpc_core::IsEventEngineDnsEnabled();
-#ifdef GRPC_PYTHON_BUILD
-  if (!grpc_core::IsEventEnginePollerForPythonEnabled()) {
-    g_backup_polling_disabled = false;
-  }
-#endif
   if (g_backup_polling_disabled) {
     return;
   }
@@ -159,21 +154,11 @@ static void g_poller_init_locked() {
   }
 }
 
-static bool g_can_poll_in_background() {
-#ifndef GRPC_PYTHON_BUILD
-  return grpc_iomgr_run_in_background();
-#else
-  // No iomgr "event_engines" (not to be confused with the new EventEngine)
-  // are able to run in backgroung.
-  return false;
-#endif
-}
-
 void grpc_client_channel_start_backup_polling(
     grpc_pollset_set* interested_parties) {
   if (g_backup_polling_disabled ||
       g_poll_interval == grpc_core::Duration::Zero() ||
-      g_can_poll_in_background()) {
+      grpc_iomgr_run_in_background()) {
     return;
   }
   gpr_mu_lock(&g_poller_mu);
@@ -193,7 +178,7 @@ void grpc_client_channel_stop_backup_polling(
     grpc_pollset_set* interested_parties) {
   if (g_backup_polling_disabled ||
       g_poll_interval == grpc_core::Duration::Zero() ||
-      g_can_poll_in_background()) {
+      grpc_iomgr_run_in_background()) {
     return;
   }
   grpc_pollset_set_del_pollset(interested_parties, g_poller->pollset);

data/src/core/client_channel/client_channel.cc

@@ -404,20 +404,18 @@ void ClientChannel::SubchannelWrapper::Orphaned() {
           }
           self->client_channel_->subchannel_map_.erase(it);
         }
-        if (IsSubchannelWrapperCleanupOnOrphanEnabled()) {
-          // We need to make sure that the internal subchannel gets unreffed
-          // inside of the WorkSerializer, so that updates to the local
-          // subchannel pool are properly synchronized.  To that end, we
-          // drop our ref to the internal subchannel here.  We also cancel
-          // any watchers that were not properly cancelled, in case any of
-          // them are holding a ref to the internal subchannel.
-          for (const auto& [_, watcher] : self->watcher_map_) {
-            self->subchannel_->CancelConnectivityStateWatch(watcher);
-          }
-          self->watcher_map_.clear();
-          self->data_watchers_.clear();
-          self->subchannel_.reset();
+        // We need to make sure that the internal subchannel gets unreffed
+        // inside of the WorkSerializer, so that updates to the local
+        // subchannel pool are properly synchronized.  To that end, we
+        // drop our ref to the internal subchannel here.  We also cancel
+        // any watchers that were not properly cancelled, in case any of
+        // them are holding a ref to the internal subchannel.
+        for (const auto& [_, watcher] : self->watcher_map_) {
+          self->subchannel_->CancelConnectivityStateWatch(watcher);
         }
+        self->watcher_map_.clear();
+        self->data_watchers_.clear();
+        self->subchannel_.reset();
       });
 }
 
@@ -898,10 +896,15 @@ void ClientChannel::Ping(grpc_completion_queue*, void*) {
 grpc_call* ClientChannel::CreateCall(
     grpc_call* parent_call, uint32_t propagation_mask,
     grpc_completion_queue* cq, grpc_pollset_set* /*pollset_set_alternative*/,
-    Slice path, std::optional<Slice> authority, Timestamp deadline, bool) {
+    Slice path, std::optional<Slice> authority, Timestamp deadline,
+    bool /*registered_method*/,
+    std::optional<absl::FunctionRef<void(Arena*)>> arena_init_function) {
   auto arena = call_arena_allocator()->MakeArena();
   arena->SetContext<grpc_event_engine::experimental::EventEngine>(
       event_engine());
+  if (arena_init_function.has_value()) {
+    (*arena_init_function)(arena.get());
+  }
   return MakeClientCall(parent_call, propagation_mask, cq, std::move(path),
                         std::move(authority), false, deadline,
                         compression_options(), std::move(arena), Ref());
@@ -924,12 +927,10 @@ class FilterChainBuilderImpl final : public FilterChainBuilder {
  public:
   FilterChainBuilderImpl(
       bool enable_retries, const ChannelArgs& channel_args,
-      Blackboard* blackboard,
       std::function<void(ServerMetadata&)> on_server_trailing_metadata,
       RefCountedPtr<UnstartedCallDestination> destination)
       : enable_retries_(enable_retries),
         channel_args_(channel_args),
-        blackboard_(blackboard),
         on_server_trailing_metadata_(std::move(on_server_trailing_metadata)),
         destination_(std::move(destination)) {}
 
@@ -954,8 +955,7 @@ class FilterChainBuilderImpl final : public FilterChainBuilder {
   }
 
   void InitBuilder() {
-    builder_ =
-        std::make_unique<InterceptionChainBuilder>(channel_args_, blackboard_);
+    builder_ = std::make_unique<InterceptionChainBuilder>(channel_args_);
     if (on_server_trailing_metadata_ != nullptr) {
       builder_->AddOnServerTrailingMetadata(on_server_trailing_metadata_);
     }
@@ -965,7 +965,6 @@ class FilterChainBuilderImpl final : public FilterChainBuilder {
 
   const bool enable_retries_;
   const ChannelArgs channel_args_;
-  const Blackboard* blackboard_;
   const std::function<void(ServerMetadata&)> on_server_trailing_metadata_;
   const RefCountedPtr<UnstartedCallDestination> destination_;
   std::unique_ptr<InterceptionChainBuilder> builder_;
@@ -1392,15 +1391,13 @@ void ClientChannel::UpdateServiceConfigInDataPlaneLocked(
   }
   // Modify channel args.
   ChannelArgs new_args = args.SetObject(this).SetObject(saved_service_config_);
-  // Construct filter stack.
-  auto new_blackboard = MakeRefCounted<Blackboard>();
   const bool enable_retries =
       !channel_args_.WantMinimalStack() &&
       channel_args_.GetBool(GRPC_ARG_ENABLE_RETRIES).value_or(true);
   if (enable_retries) {
-    RetryInterceptor::UpdateBlackboard(*saved_service_config_,
-                                       blackboard_.get(), new_blackboard.get());
+    retry_throttler_updater_.Update(*saved_service_config_, new_args);
   }
+  // Construct filter stack.
   std::function<void(ServerMetadata&)> on_server_trailing_metadata;
   if (idle_timeout_ != Duration::Zero()) {
     on_server_trailing_metadata = [this](ServerMetadata&) {
@@ -1408,11 +1405,9 @@ void ClientChannel::UpdateServiceConfigInDataPlaneLocked(
     };
   }
   FilterChainBuilderImpl filter_chain_builder(
-      enable_retries, new_args, new_blackboard.get(),
-      std::move(on_server_trailing_metadata), call_destination_);
-  config_selector->BuildFilterChains(filter_chain_builder, blackboard_.get(),
-                                     new_blackboard.get());
-  blackboard_ = std::move(new_blackboard);
+      enable_retries, new_args, std::move(on_server_trailing_metadata),
+      call_destination_);
+  config_selector->BuildFilterChains(filter_chain_builder);
   resolver_data_for_calls_.Set(std::move(config_selector));
 }