grpc 1.73.0 → 1.74.0

data/src/core/resolver/xds/xds_resolver.cc

@@ -51,6 +51,7 @@
 #include "src/core/client_channel/client_channel_internal.h"
 #include "src/core/client_channel/config_selector.h"
 #include "src/core/config/core_configuration.h"
+#include "src/core/filter/blackboard.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
@@ -274,12 +275,16 @@ class XdsResolver final : public Resolver {
 
     absl::Status GetCallConfig(GetCallConfigArgs args) override;
 
-    void AddFilters(InterceptionChainBuilder& builder) override;
+    void AddFilters(InterceptionChainBuilder& builder,
+                    const Blackboard* old_blackboard,
+                    Blackboard* new_blackboard) override;
 
-    std::vector<const grpc_channel_filter*> GetFilters() override;
+    std::vector<const grpc_channel_filter*> GetFilters(
+        const Blackboard* old_blackboard, Blackboard* new_blackboard) override;
 
    private:
     RefCountedPtr<XdsResolver> resolver_;
+    std::shared_ptr<const XdsListenerResource> listener_;
     RefCountedPtr<RouteConfigData> route_config_data_;
     std::vector<const XdsHttpFilterImpl*> filters_;
   };
@@ -517,7 +522,7 @@ absl::Status XdsResolver::RouteConfigData::AddRouteEntry(
     XdsResolver* resolver, const XdsRouteConfigResource::Route& route,
     const Duration& default_max_stream_duration) {
   GRPC_TRACE_LOG(xds_resolver, INFO)
-      << "[xds_resolver " << resolver << "] XdsConfigSelector " << this
+      << "[xds_resolver " << resolver << "] RouteConfigData " << this
       << ": route: " << route.ToString();
   routes_.emplace_back(route);
   auto* route_entry = &routes_.back();
@@ -606,18 +611,19 @@ XdsResolver::XdsConfigSelector::XdsConfigSelector(
     RefCountedPtr<XdsResolver> resolver,
     RefCountedPtr<RouteConfigData> route_config_data)
     : resolver_(std::move(resolver)),
+      listener_(resolver_->current_config_->listener),
       route_config_data_(std::move(route_config_data)) {
   GRPC_TRACE_LOG(xds_resolver, INFO) << "[xds_resolver " << resolver_.get()
                                      << "] creating XdsConfigSelector " << this;
   // Populate filter list.
   const auto& http_filter_registry =
-      static_cast<const GrpcXdsBootstrap&>(resolver_->xds_client_->bootstrap())
+      DownCast<const GrpcXdsBootstrap&>(resolver_->xds_client_->bootstrap())
           .http_filter_registry();
-  const auto& hcm = std::get<XdsListenerResource::HttpConnectionManager>(
-      resolver_->current_config_->listener->listener);
+  const auto& hcm =
+      std::get<XdsListenerResource::HttpConnectionManager>(listener_->listener);
   for (const auto& http_filter : hcm.http_filters) {
     // Find filter.  This is guaranteed to succeed, because it's checked
-    // at config validation time in the XdsApi code.
+    // at config validation time.
     const XdsHttpFilterImpl* filter_impl =
         http_filter_registry.GetFilterForType(
             http_filter.config.config_proto_type_name);
@@ -771,20 +777,34 @@ absl::Status XdsResolver::XdsConfigSelector::GetCallConfig(
 }
 
 void XdsResolver::XdsConfigSelector::AddFilters(
-    InterceptionChainBuilder& builder) {
-  for (const XdsHttpFilterImpl* filter : filters_) {
+    InterceptionChainBuilder& builder, const Blackboard* old_blackboard,
+    Blackboard* new_blackboard) {
+  const auto& hcm =
+      std::get<XdsListenerResource::HttpConnectionManager>(listener_->listener);
+  CHECK_EQ(filters_.size(), hcm.http_filters.size());
+  for (size_t i = 0; i < filters_.size(); ++i) {
+    auto* filter = filters_[i];
     filter->AddFilter(builder);
+    filter->UpdateBlackboard(hcm.http_filters[i].config, old_blackboard,
+                             new_blackboard);
   }
   builder.Add<ClusterSelectionFilter>();
 }
 
 std::vector<const grpc_channel_filter*>
-XdsResolver::XdsConfigSelector::GetFilters() {
+XdsResolver::XdsConfigSelector::GetFilters(const Blackboard* old_blackboard,
+                                           Blackboard* new_blackboard) {
+  const auto& hcm =
+      std::get<XdsListenerResource::HttpConnectionManager>(listener_->listener);
+  CHECK_EQ(filters_.size(), hcm.http_filters.size());
   std::vector<const grpc_channel_filter*> filters;
-  for (const XdsHttpFilterImpl* filter : filters_) {
+  for (size_t i = 0; i < filters_.size(); ++i) {
+    auto* filter = filters_[i];
     if (filter->channel_filter() != nullptr) {
       filters.push_back(filter->channel_filter());
     }
+    filter->UpdateBlackboard(hcm.http_filters[i].config, old_blackboard,
+                             new_blackboard);
   }
   filters.push_back(&ClusterSelectionFilter::kFilter);
   return filters;

data/src/core/server/server.cc

@@ -48,6 +48,7 @@
 #include "src/core/call/server_call.h"
 #include "src/core/channelz/channel_trace.h"
 #include "src/core/channelz/channelz.h"
+#include "src/core/channelz/property_list.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/credentials/transport/transport_credentials.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
@@ -105,6 +106,16 @@ void Server::ListenerState::ConfigFetcherWatcher::UpdateConnectionManager(
     if (listener_state_->server_->ShutdownCalled()) {
       return;
     }
+    RefCountedPtr<Blackboard> new_blackboard;
+    for (auto& blackboard_shard : listener_state_->blackboards_) {
+      MutexLock lock(&blackboard_shard.mu);
+      if (new_blackboard == nullptr) {
+        new_blackboard = MakeRefCounted<Blackboard>();
+        listener_state_->connection_manager_->UpdateBlackboard(
+            blackboard_shard.blackboard.get(), new_blackboard.get());
+      }
+      blackboard_shard.blackboard = new_blackboard;
+    }
     listener_state_->is_serving_ = true;
     if (listener_state_->started_) return;
     listener_state_->started_ = true;
@@ -131,7 +142,8 @@ Server::ListenerState::ListenerState(RefCountedPtr<Server> server,
       event_engine_(
           server_->channel_args()
               .GetObject<grpc_event_engine::experimental::EventEngine>()),
-      listener_(std::move(l)) {
+      listener_(std::move(l)),
+      blackboards_(PerCpuOptions().SetMaxShards(16)) {
   auto max_allowed_incoming_connections =
       server_->channel_args().GetInt(GRPC_ARG_MAX_ALLOWED_INCOMING_CONNECTIONS);
   if (max_allowed_incoming_connections.has_value()) {
@@ -277,6 +289,19 @@ void Server::ListenerState::RemoveLogicalConnection(
   }
 }
 
+grpc_error_handle Server::ListenerState::SetupTransport(
+    Transport* transport, grpc_pollset* accepting_pollset,
+    const ChannelArgs& args) {
+  RefCountedPtr<Blackboard> blackboard;
+  {
+    auto& blackboard_shard = blackboards_.this_cpu();
+    MutexLock lock(&blackboard_shard.mu);
+    blackboard = blackboard_shard.blackboard;
+  }
+  return server_->SetupTransport(transport, accepting_pollset, args,
+                                 blackboard.get());
+}
+
 void Server::ListenerState::DrainConnectionsLocked() {
   if (connections_.empty()) {
     return;
@@ -1060,9 +1085,7 @@ RefCountedPtr<channelz::ServerNode> CreateChannelzNode(
                .value_or(GRPC_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE_DEFAULT));
     channelz_node =
         MakeRefCounted<channelz::ServerNode>(channel_tracer_max_memory);
-    channelz_node->AddTraceEvent(
-        channelz::ChannelTrace::Severity::Info,
-        grpc_slice_from_static_string("Server created"));
+    GRPC_CHANNELZ_LOG(channelz_node) << "Server created";
     channelz_node->SetChannelArgs(args);
   }
   return channelz_node;
@@ -1151,8 +1174,9 @@ auto Server::MatchAndPublishCall(CallHandler call_handler) {
 }
 
 absl::StatusOr<RefCountedPtr<UnstartedCallDestination>>
-Server::MakeCallDestination(const ChannelArgs& args) {
-  InterceptionChainBuilder builder(args);
+Server::MakeCallDestination(const ChannelArgs& args,
+                            const Blackboard* blackboard) {
+  InterceptionChainBuilder builder(args, blackboard);
   // TODO(ctiller): find a way to avoid adding a server ref per call
   builder.AddOnClientInitialMetadata([self = Ref()](ClientMetadata& md) {
     self->SetRegisteredMethodOnMetadata(md);
@@ -1166,16 +1190,23 @@ Server::MakeCallDestination(const ChannelArgs& args) {
 }
 
 Server::Server(const ChannelArgs& args)
-    : channel_args_(args),
-      channelz_node_(CreateChannelzNode(args)),
+    : channelz::DataSource(CreateChannelzNode(args)),
+      channel_args_(args),
+      channelz_node_(channelz::DataSource::channelz_node() == nullptr
+                         ? nullptr
+                         : channelz::DataSource::channelz_node()
+                               ->RefAsSubclass<channelz::ServerNode>()),
       server_call_tracer_factory_(ServerCallTracerFactory::Get(args)),
       compression_options_(CompressionOptionsFromChannelArgs(args)),
       max_time_in_pending_queue_(Duration::Seconds(
           channel_args_
               .GetInt(GRPC_ARG_SERVER_MAX_UNREQUESTED_TIME_IN_SERVER_SECONDS)
-              .value_or(30))) {}
+              .value_or(30))) {
+  SourceConstructed();
+}
 
 Server::~Server() {
+  SourceDestructing();
   // Remove the cq pollsets from the config_fetcher.
   if (started_ && config_fetcher_ != nullptr &&
       config_fetcher_->interested_parties() != nullptr) {
@@ -1189,6 +1220,44 @@ Server::~Server() {
   }
 }
 
+void Server::AddData(channelz::DataSink sink) {
+  MutexLock global_lock(&mu_global_);
+  sink.AddData(
+      "server",
+      channelz::PropertyList()
+          // TODO(ctiller): config_fetcher?
+          // TODO(ctiller): server_call_tracer_factory?
+          // TODO(ctiller): compression_options?
+          // TODO(ctiller): unregistered_request_matcher?
+          // TODO(ctiller): connection_manager?
+          .Set("registered_cqs", cqs_.size())
+          .Set("pollsets", pollsets_.size())
+          .Set("started", started_)
+          .Set("starting", starting_)
+          .Set("registered_methods",
+               [this]() {
+                 channelz::PropertyGrid grid;
+                 for (auto& [host_method, rm] : registered_methods_) {
+                   grid.Set("host", host_method.second, host_method.first)
+                       .Set("payload_handling", host_method.second,
+                            rm->payload_handling ==
+                                    GRPC_SRM_PAYLOAD_READ_INITIAL_BYTE_BUFFER
+                                ? "READ_INITIAL_BYTE_BUFFER"
+                                : "PAYLOAD_NONE");
+                 }
+                 return grid;
+               }())
+          .Set("shutdown_refs", shutdown_refs_.load(std::memory_order_relaxed))
+          .Set("shutdown_published", shutdown_published_)
+          .Set("num_shutdown_tags", shutdown_tags_.size())
+          .Set("max_time_in_pending_queue", max_time_in_pending_queue_)
+          .Set("num_channels", channels_.size())
+          .Set("num_connections", connections_.size())
+          .Set("connections_open", connections_open_)
+          .Set("num_listener_states", listener_states_.size())
+          .Set("listeners_destroyed", listeners_destroyed_));
+}
+
 void Server::AddListener(OrphanablePtr<ListenerInterface> listener) {
   channelz::ListenSocketNode* listen_socket_node =
       listener->channelz_listen_socket_node();
@@ -1240,7 +1309,8 @@ void Server::Start() {
 
 grpc_error_handle Server::SetupTransport(Transport* transport,
                                          grpc_pollset* accepting_pollset,
-                                         const ChannelArgs& args) {
+                                         const ChannelArgs& args,
+                                         const Blackboard* blackboard) {
   GRPC_LATENT_SEE_INNER_SCOPE("Server::SetupTransport");
   // Create channel.
   global_stats().IncrementServerChannelsCreated();
@@ -1252,7 +1322,8 @@ grpc_error_handle Server::SetupTransport(Transport* transport,
     OrphanablePtr<ServerTransport> t(transport->server_transport());
     auto destination = MakeCallDestination(
         args.SetObject(transport).SetObject<channelz::BaseNode>(
-            transport->GetSocketNode()));
+            transport->GetSocketNode()),
+        blackboard);
     if (!destination.ok()) {
       return absl_status_to_grpc_error(destination.status());
     }
@@ -1275,7 +1346,7 @@ grpc_error_handle Server::SetupTransport(Transport* transport,
         "",
         args.SetObject(transport).SetObject<channelz::BaseNode>(
             transport->GetSocketNode()),
-        GRPC_SERVER_CHANNEL);
+        GRPC_SERVER_CHANNEL, blackboard);
     if (!channel.ok()) {
       return absl_status_to_grpc_error(channel.status());
     }

data/src/core/server/server.h

@@ -45,6 +45,7 @@
 #include "absl/strings/string_view.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/channelz/channelz.h"
+#include "src/core/filter/blackboard.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
@@ -66,6 +67,7 @@
 #include "src/core/util/cpp_impl_of.h"
 #include "src/core/util/dual_ref_counted.h"
 #include "src/core/util/orphanable.h"
+#include "src/core/util/per_cpu.h"
 #include "src/core/util/random_early_detection.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/sync.h"
@@ -86,6 +88,9 @@ class ServerConfigFetcher
     virtual absl::StatusOr<grpc_core::ChannelArgs>
     UpdateChannelArgsForConnection(const grpc_core::ChannelArgs& args,
                                    grpc_endpoint* tcp) = 0;
+
+    virtual void UpdateBlackboard(const Blackboard* old_blackboard,
+                                  Blackboard* new_blackboard) = 0;
   };
 
   class WatcherInterface {
@@ -120,6 +125,7 @@ class ListenerStateTestPeer;
 
 class Server : public ServerInterface,
                public InternallyRefCounted<Server>,
+               public channelz::DataSource,
                public CppImplOf<Server, grpc_server> {
  public:
   // Filter vtable.
@@ -246,6 +252,10 @@ class Server : public ServerInterface,
     void RemoveLogicalConnection(
         ListenerInterface::LogicalConnection* connection);
 
+    grpc_error_handle SetupTransport(Transport* transport,
+                                     grpc_pollset* accepting_pollset,
+                                     const ChannelArgs& args);
+
     const MemoryQuotaRefPtr& memory_quota() const { return memory_quota_; }
 
     const ConnectionQuotaRefPtr& connection_quota() const {
@@ -282,6 +292,11 @@ class Server : public ServerInterface,
       grpc_core::Timestamp timestamp;
     };
 
+    struct BlackboardShard {
+      Mutex mu;
+      RefCountedPtr<Blackboard> blackboard ABSL_GUARDED_BY(&mu);
+    };
+
     void DrainConnectionsLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
 
     void OnDrainGraceTimer();
@@ -299,6 +314,7 @@ class Server : public ServerInterface,
     OrphanablePtr<ListenerInterface> listener_;
     grpc_closure destroy_done_;
     ConfigFetcherWatcher* config_fetcher_watcher_ = nullptr;
+    PerCpu<BlackboardShard> blackboards_;
     Mutex mu_;  // We could share this mutex with Listener implementations. It's
                 // a tradeoff between increased memory requirement and more
                 // granular critical regions.
@@ -318,6 +334,8 @@ class Server : public ServerInterface,
   explicit Server(const ChannelArgs& args);
   ~Server() override;
 
+  void AddData(channelz::DataSink sink) override;
+
   void Orphan() ABSL_LOCKS_EXCLUDED(mu_global_) override;
 
   const ChannelArgs& channel_args() const override { return channel_args_; }
@@ -355,7 +373,8 @@ class Server : public ServerInterface,
   // Takes ownership of a ref on resource_user from the caller.
   grpc_error_handle SetupTransport(Transport* transport,
                                    grpc_pollset* accepting_pollset,
-                                   const ChannelArgs& args)
+                                   const ChannelArgs& args,
+                                   const Blackboard* blackboard = nullptr)
       ABSL_LOCKS_EXCLUDED(mu_global_);
 
   void RegisterCompletionQueue(grpc_completion_queue* cq);
@@ -641,7 +660,7 @@ class Server : public ServerInterface,
                                             ClientMetadataHandle md);
   auto MatchAndPublishCall(CallHandler call_handler);
   absl::StatusOr<RefCountedPtr<UnstartedCallDestination>> MakeCallDestination(
-      const ChannelArgs& args);
+      const ChannelArgs& args, const Blackboard* blackboard);
 
   ChannelArgs const channel_args_;
   RefCountedPtr<channelz::ServerNode> channelz_node_;

data/src/core/server/xds_server_config_fetcher.cc

@@ -70,6 +70,7 @@
 #include "src/core/service_config/service_config.h"
 #include "src/core/service_config/service_config_impl.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/down_cast.h"
 #include "src/core/util/host_port.h"
 #include "src/core/util/match.h"
 #include "src/core/util/ref_counted_ptr.h"
@@ -210,6 +211,9 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager final
   absl::StatusOr<ChannelArgs> UpdateChannelArgsForConnection(
       const ChannelArgs& args, grpc_endpoint* tcp) override;
 
+  void UpdateBlackboard(const Blackboard* old_blackboard,
+                        Blackboard* new_blackboard) override;
+
   // Invoked by ListenerWatcher to start fetching referenced RDS resources.
   void StartRdsWatch(RefCountedPtr<ListenerWatcher> listener_watcher)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(&ListenerWatcher::mu_);
@@ -248,6 +252,10 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager final
           route_config);
   void OnAmbientError(const std::string& resource_name, absl::Status status);
 
+  // Executes cb once for each unique filter chain object in the LDS resource.
+  void ForEachFilterChain(
+      absl::FunctionRef<void(XdsListenerResource::FilterChainData&)> cb);
+
   RefCountedPtr<GrpcXdsClient> xds_client_;
   // This ref is only kept around till the FilterChainMatchManager becomes
   // ready.
@@ -402,7 +410,7 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
       return static_resource_.status();
     }
     return XdsServerConfigSelector::Create(
-        static_cast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
+        DownCast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
             .http_filter_registry(),
         static_resource_.value(), http_filters_);
   }
@@ -529,7 +537,7 @@ void XdsServerConfigFetcher::StartWatch(
   XdsListenerResourceType::StartWatch(
       xds_client_.get(),
       ListenerResourceName(
-          static_cast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
+          DownCast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
               .server_listener_resource_name_template(),
           listening_address),
       std::move(listener_watcher));
@@ -546,7 +554,7 @@ void XdsServerConfigFetcher::CancelWatch(
     XdsListenerResourceType::CancelWatch(
         xds_client_.get(),
         ListenerResourceName(
-            static_cast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
+            DownCast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
                 .server_listener_resource_name_template(),
             it->second->listening_address()),
         it->second, false /* delay_unsubscription */);
@@ -685,37 +693,47 @@ XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
       default_filter_chain_(std::move(default_filter_chain)) {}
 
 void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
-    StartRdsWatch(RefCountedPtr<ListenerWatcher> listener_watcher) {
-  // Get the set of RDS resources to watch on. Also get the set of
-  // FilterChainData so that we can reverse the list of HTTP filters since
-  // received data moves *up* the stack in Core.
-  std::set<std::string> resource_names;
+    ForEachFilterChain(
+        absl::FunctionRef<void(XdsListenerResource::FilterChainData&)> cb) {
+  // A given FilterChainData object may appear more than once in the map,
+  // but we want to invoke the callback exactly once for each
+  // FilterChainData object.  Therefore, we start by constructing a set
+  // of all FilterChainData objects by address, to weed out duplicates.
   std::set<XdsListenerResource::FilterChainData*> filter_chain_data_set;
   for (const auto& destination_ip : filter_chain_map_.destination_ip_vector) {
     for (const auto& source_type : destination_ip.source_types_array) {
       for (const auto& source_ip : source_type) {
         for (const auto& source_port_pair : source_ip.ports_map) {
           auto* filter_chain_data = source_port_pair.second.data.get();
-          const auto* rds_name = std::get_if<std::string>(
-              &filter_chain_data->http_connection_manager.route_config);
-          if (rds_name != nullptr) resource_names.insert(*rds_name);
           filter_chain_data_set.insert(filter_chain_data);
         }
       }
     }
   }
-  if (default_filter_chain_.has_value()) {
-    auto& hcm = default_filter_chain_->http_connection_manager;
-    const auto* rds_name = std::get_if<std::string>(&hcm.route_config);
-    if (rds_name != nullptr) resource_names.insert(*rds_name);
-    std::reverse(hcm.http_filters.begin(), hcm.http_filters.end());
-  }
-  // Reverse the lists of HTTP filters in all the filter chains
+  // Invoke the callback once for each FilterChainData object.
   for (auto* filter_chain_data : filter_chain_data_set) {
-    auto& hcm = filter_chain_data->http_connection_manager;
-    std::reverse(hcm.http_filters.begin(), hcm.http_filters.end());
+    cb(*filter_chain_data);
   }
-  // Start watching on referenced RDS resources
+  // Also invoke the callback for the default filter chain, if present.
+  if (default_filter_chain_.has_value()) {
+    cb(*default_filter_chain_);
+  }
+}
+
+void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
+    StartRdsWatch(RefCountedPtr<ListenerWatcher> listener_watcher) {
+  // Get the set of RDS resources to watch on. Also reverse the list of
+  // HTTP filters in each filter chain, since received data moves *up*
+  // the stack on the server side.
+  std::set<std::string> resource_names;
+  ForEachFilterChain(
+      [&](XdsListenerResource::FilterChainData& filter_chain_data) {
+        auto& hcm = filter_chain_data.http_connection_manager;
+        const auto* rds_name = std::get_if<std::string>(&hcm.route_config);
+        if (rds_name != nullptr) resource_names.insert(*rds_name);
+        std::reverse(hcm.http_filters.begin(), hcm.http_filters.end());
+      });
+  // Start watching referenced RDS resources.
   struct WatcherToStart {
     std::string resource_name;
     RefCountedPtr<RouteConfigWatcher> watcher;
@@ -1026,7 +1044,7 @@ absl::StatusOr<ChannelArgs> XdsServerConfigFetcher::ListenerWatcher::
   // flows *up* the stack.
   std::vector<const grpc_channel_filter*> filters;
   const auto& http_filter_registry =
-      static_cast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
+      DownCast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
           .http_filter_registry();
   for (const auto& http_filter :
        filter_chain->http_connection_manager.http_filters) {
@@ -1090,6 +1108,26 @@ absl::StatusOr<ChannelArgs> XdsServerConfigFetcher::ListenerWatcher::
   return args;
 }
 
+void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
+    UpdateBlackboard(const Blackboard* old_blackboard,
+                     Blackboard* new_blackboard) {
+  const auto& http_filter_registry =
+      DownCast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
+          .http_filter_registry();
+  ForEachFilterChain(
+      [&](XdsListenerResource::FilterChainData& filter_chain_data) {
+        auto& hcm = filter_chain_data.http_connection_manager;
+        for (const auto& http_filter : hcm.http_filters) {
+          const XdsHttpFilterImpl* filter_impl =
+              http_filter_registry.GetFilterForType(
+                  http_filter.config.config_proto_type_name);
+          CHECK_NE(filter_impl, nullptr);  // Enforced in config validation.
+          filter_impl->UpdateBlackboard(http_filter.config, old_blackboard,
+                                        new_blackboard);
+        }
+      });
+}
+
 //
 // XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::XdsServerConfigSelector
 //
@@ -1237,7 +1275,7 @@ XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
     return resource.status();
   }
   return XdsServerConfigSelector::Create(
-      static_cast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
+      DownCast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
           .http_filter_registry(),
       resource.value(), http_filters_);
 }
@@ -1269,7 +1307,7 @@ void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
     watcher_->OnServerConfigSelectorUpdate(resource_.status());
   } else {
     watcher_->OnServerConfigSelectorUpdate(XdsServerConfigSelector::Create(
-        static_cast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
+        DownCast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
             .http_filter_registry(),
         *resource_, http_filters_));
   }
@@ -1304,7 +1342,7 @@ grpc_server_config_fetcher* grpc_server_config_fetcher_xds_create(
     LOG(ERROR) << "Failed to create xds client: " << xds_client.status();
     return nullptr;
   }
-  if (static_cast<const grpc_core::GrpcXdsBootstrap&>(
+  if (grpc_core::DownCast<const grpc_core::GrpcXdsBootstrap&>(
           (*xds_client)->bootstrap())
           .server_listener_resource_name_template()
           .empty()) {

data/src/core/service_config/service_config.h

@@ -72,7 +72,7 @@ class ServiceConfig : public RefCounted<ServiceConfig> {
   /// lifetime of the returned object is tied to the lifetime of the
   /// ServiceConfig object.
   virtual ServiceConfigParser::ParsedConfig* GetGlobalParsedConfig(
-      size_t index) = 0;
+      size_t index) const = 0;
 
   /// Retrieves the vector of parsed configs for the method identified
   /// by \a path.  The lifetime of the returned vector and contained objects

data/src/core/service_config/service_config_impl.h

@@ -86,7 +86,7 @@ class ServiceConfigImpl final : public ServiceConfig {
   /// lifetime of the returned object is tied to the lifetime of the
   /// ServiceConfig object.
   ServiceConfigParser::ParsedConfig* GetGlobalParsedConfig(
-      size_t index) override {
+      size_t index) const override {
     DCHECK(index < parsed_global_configs_.size());
     return parsed_global_configs_[index].get();
   }

data/src/core/telemetry/context_list_entry.cc

@@ -0,0 +1,38 @@
+// Copyright 2025 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/core/telemetry/context_list_entry.h"
+
+namespace grpc_core {
+
+namespace {
+CopyContextFn g_get_copied_context_fn = nullptr;
+DeleteContextFn g_delete_copied_context_fn = nullptr;
+}  // namespace
+
+void GrpcHttp2SetCopyContextFn(CopyContextFn fn) {
+  g_get_copied_context_fn = fn;
+}
+
+void GrpcHttp2SetDeleteContextFn(DeleteContextFn fn) {
+  g_delete_copied_context_fn = fn;
+}
+
+CopyContextFn GrpcHttp2GetCopyContextFn() { return g_get_copied_context_fn; }
+
+DeleteContextFn GrpcHttp2GetDeleteContextFn() {
+  return g_delete_copied_context_fn;
+}
+
+}  // namespace grpc_core