grpc 1.75.0 → 1.78.1

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

@@ -32,13 +32,13 @@
 #include <string>
 #include <vector>
 
+#include "src/core/util/useful.h"
 #include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
-#include "src/core/util/useful.h"
 
 namespace grpc_core {
 

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

@@ -33,8 +33,6 @@
 #include <type_traits>
 #include <utility>
 
-#include "absl/meta/type_traits.h"
-#include "absl/strings/string_view.h"
 #include "src/core/channelz/property_list.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/util/avl.h"
@@ -45,6 +43,8 @@
 #include "src/core/util/ref_counted_string.h"
 #include "src/core/util/time.h"
 #include "src/core/util/useful.h"
+#include "absl/meta/type_traits.h"
+#include "absl/strings/string_view.h"
 
 // TODO(hork): When we're ready to allow setting via a channel arg from the
 // application, replace this with a macro in

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

@@ -24,13 +24,14 @@
 #include <memory>
 #include <utility>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "src/core/channelz/property_list.h"
+#include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/surface/channel_init.h"
 #include "src/core/util/alloc.h"
+#include "src/core/util/grpc_check.h"
+#include "absl/log/log.h"
 
 using grpc_event_engine::experimental::EventEngine;
 
@@ -57,20 +58,19 @@ static int register_get_name_fn = []() {
 //   per-filter memory, aligned to GPR_MAX_ALIGNMENT
 // }
 
-size_t grpc_channel_stack_size(const grpc_channel_filter** filters,
-                               size_t filter_count) {
+size_t grpc_channel_stack_size(
+    const std::vector<grpc_core::FilterAndConfig>& filters) {
   // always need the header, and size for the channel elements
   size_t size = GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_channel_stack)) +
-                GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filter_count *
+                GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filters.size() *
                                                sizeof(grpc_channel_element));
-  size_t i;
 
-  CHECK((GPR_MAX_ALIGNMENT & (GPR_MAX_ALIGNMENT - 1)) == 0)
+  GRPC_CHECK((GPR_MAX_ALIGNMENT & (GPR_MAX_ALIGNMENT - 1)) == 0)
       << "GPR_MAX_ALIGNMENT must be a power of two";
 
   // add the size for each filter
-  for (i = 0; i < filter_count; i++) {
-    size += GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filters[i]->sizeof_channel_data);
+  for (const auto& [filter, _] : filters) {
+    size += GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filter->sizeof_channel_data);
   }
 
   return size;
@@ -113,13 +113,13 @@ grpc_call_element* grpc_call_stack_element(grpc_call_stack* call_stack,
 
 grpc_error_handle grpc_channel_stack_init(
     int initial_refs, grpc_iomgr_cb_func destroy, void* destroy_arg,
-    const grpc_channel_filter** filters, size_t filter_count,
+    std::vector<grpc_core::FilterAndConfig> filters,
     const grpc_core::ChannelArgs& channel_args, const char* name,
     grpc_channel_stack* stack, const grpc_core::Blackboard* blackboard) {
   if (GRPC_TRACE_FLAG_ENABLED(channel_stack)) {
     LOG(INFO) << "CHANNEL_STACK: init " << name;
-    for (size_t i = 0; i < filter_count; i++) {
-      LOG(INFO) << "CHANNEL_STACK:   filter " << filters[i]->name;
+    for (const auto& [filter, _] : filters) {
+      LOG(INFO) << "CHANNEL_STACK:   filter " << filter->name;
     }
   }
 
@@ -127,31 +127,32 @@ grpc_error_handle grpc_channel_stack_init(
   stack->event_engine.Init(channel_args.GetObjectRef<EventEngine>());
   stack->stats_plugin_group.Init();
 
-  size_t call_size =
-      GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_call_stack)) +
-      GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filter_count * sizeof(grpc_call_element));
+  size_t call_size = GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_call_stack)) +
+                     GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filters.size() *
+                                                    sizeof(grpc_call_element));
   grpc_channel_element* elems;
   grpc_channel_element_args args;
   char* user_data;
   size_t i;
 
-  stack->count = filter_count;
+  stack->count = filters.size();
   GRPC_STREAM_REF_INIT(&stack->refcount, initial_refs, destroy, destroy_arg,
                        name);
   elems = CHANNEL_ELEMS_FROM_STACK(stack);
   user_data = (reinterpret_cast<char*>(elems)) +
-              GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filter_count *
+              GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filters.size() *
                                              sizeof(grpc_channel_element));
 
   // init per-filter data
   args.blackboard = blackboard;
   grpc_error_handle first_error;
-  for (i = 0; i < filter_count; i++) {
+  for (i = 0; i < filters.size(); ++i) {
     args.channel_stack = stack;
     args.channel_args = channel_args;
     args.is_first = i == 0;
-    args.is_last = i == (filter_count - 1);
-    elems[i].filter = filters[i];
+    args.is_last = i == (filters.size() - 1);
+    args.config = std::move(filters[i].config);
+    elems[i].filter = filters[i].filter;
     elems[i].channel_data = user_data;
     grpc_error_handle error =
         elems[i].filter->init_channel_elem(&elems[i], &args);
@@ -161,13 +162,14 @@ grpc_error_handle grpc_channel_stack_init(
       }
     }
     user_data +=
-        GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filters[i]->sizeof_channel_data);
-    call_size += GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filters[i]->sizeof_call_data);
+        GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filters[i].filter->sizeof_channel_data);
+    call_size +=
+        GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filters[i].filter->sizeof_call_data);
   }
 
-  CHECK(user_data > (char*)stack);
-  CHECK((uintptr_t)(user_data - (char*)stack) ==
-        grpc_channel_stack_size(filters, filter_count));
+  GRPC_CHECK(user_data > (char*)stack);
+  GRPC_CHECK((uintptr_t)(user_data - (char*)stack) ==
+             grpc_channel_stack_size(filters));
 
   stack->call_stack_size = call_size;
   stack->channelz_data_source.Init(
@@ -180,6 +182,8 @@ void grpc_channel_stack::ChannelStackDataSource::AddData(
   grpc_channel_stack* channel_stack = reinterpret_cast<grpc_channel_stack*>(
       reinterpret_cast<char*>(this) -
       offsetof(grpc_channel_stack, channelz_data_source));
+  grpc_core::CoreConfiguration::Get().channel_init().AddData(
+      sink, channel_stack->type);
   sink.AddData(
       "channel_stack",
       grpc_core::channelz::PropertyList()

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

@@ -48,6 +48,7 @@
 #include <functional>
 #include <memory>
 
+#include "src/core/filter/filter_args.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/debug/trace.h"
@@ -57,6 +58,7 @@
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/resource_quota/arena.h"
+#include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/transport/call_final_info.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/telemetry/metrics.h"
@@ -75,6 +77,7 @@ struct grpc_channel_element_args {
   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 {
@@ -187,6 +190,8 @@ struct grpc_channel_stack {
   // should look like and this can go.
   grpc_core::ManualConstructor<std::function<void()>> on_destroy;
 
+  grpc_channel_stack_type type;
+
   class ChannelStackDataSource final : public grpc_core::channelz::DataSource {
    public:
     explicit ChannelStackDataSource(
@@ -264,12 +269,12 @@ size_t grpc_channel_stack_filter_instance_number(
 grpc_call_element* grpc_call_stack_element(grpc_call_stack* stack, size_t i);
 
 // Determine memory required for a channel stack containing a set of filters
-size_t grpc_channel_stack_size(const grpc_channel_filter** filters,
-                               size_t filter_count);
+size_t grpc_channel_stack_size(
+    const std::vector<grpc_core::FilterAndConfig>& filters);
 // Initialize a channel stack given some filters
 grpc_error_handle grpc_channel_stack_init(
     int initial_refs, grpc_iomgr_cb_func destroy, void* destroy_arg,
-    const grpc_channel_filter** filters, size_t filter_count,
+    std::vector<grpc_core::FilterAndConfig> filters,
     const grpc_core::ChannelArgs& args, const char* name,
     grpc_channel_stack* stack,
     const grpc_core::Blackboard* blackboard = nullptr);

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

@@ -40,12 +40,16 @@ ChannelStackBuilder& ChannelStackBuilder::SetTarget(const char* target) {
   return *this;
 }
 
-void ChannelStackBuilder::PrependFilter(const grpc_channel_filter* filter) {
-  stack_.insert(stack_.begin(), filter);
+void ChannelStackBuilder::PrependFilter(
+    const grpc_channel_filter* filter,
+    RefCountedPtr<const FilterConfig> config) {
+  stack_.insert(stack_.begin(), {filter, std::move(config)});
 }
 
-void ChannelStackBuilder::AppendFilter(const grpc_channel_filter* filter) {
-  stack_.push_back(filter);
+void ChannelStackBuilder::AppendFilter(
+    const grpc_channel_filter* filter,
+    RefCountedPtr<const FilterConfig> config) {
+  stack_.push_back({filter, std::move(config)});
 }
 
 }  // namespace grpc_core

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

@@ -20,12 +20,13 @@
 #include <string>
 #include <vector>
 
-#include "absl/status/statusor.h"
-#include "absl/strings/string_view.h"
+#include "src/core/filter/filter_args.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 
@@ -53,12 +54,10 @@ class ChannelStackBuilder {
   const ChannelArgs& channel_args() const { return args_; }
 
   // Mutable vector of proposed stack entries.
-  std::vector<const grpc_channel_filter*>* mutable_stack() { return &stack_; }
+  std::vector<FilterAndConfig>* mutable_stack() { return &stack_; }
 
   // Immutable vector of proposed stack entries.
-  const std::vector<const grpc_channel_filter*>& stack() const {
-    return stack_;
-  }
+  const std::vector<FilterAndConfig>& stack() const { return stack_; }
 
   // The type of channel stack being built.
   grpc_channel_stack_type channel_stack_type() const { return type_; }
@@ -68,10 +67,12 @@ class ChannelStackBuilder {
   // channel init.
 
   // Helper to add a filter to the front of the stack.
-  void PrependFilter(const grpc_channel_filter* filter);
+  void PrependFilter(const grpc_channel_filter* filter,
+                     RefCountedPtr<const FilterConfig> config = nullptr);
 
   // Helper to add a filter to the end of the stack.
-  void AppendFilter(const grpc_channel_filter* filter);
+  void AppendFilter(const grpc_channel_filter* filter,
+                    RefCountedPtr<const FilterConfig> config = nullptr);
 
   // Build the channel stack.
   // After success, *result holds the new channel stack,
@@ -95,7 +96,7 @@ class ChannelStackBuilder {
   // Channel args
   ChannelArgs args_;
   // The in-progress stack
-  std::vector<const grpc_channel_filter*> stack_;
+  std::vector<FilterAndConfig> stack_;
 };
 
 }  // namespace grpc_core

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

@@ -29,10 +29,6 @@
 #include <utility>
 #include <vector>
 
-#include "absl/base/thread_annotations.h"
-#include "absl/container/flat_hash_map.h"
-#include "absl/status/status.h"
-#include "absl/strings/str_cat.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
@@ -47,24 +43,24 @@
 #include "src/core/lib/transport/transport.h"
 #include "src/core/util/no_destruct.h"
 #include "src/core/util/sync.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/container/flat_hash_map.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
 
 namespace grpc_core {
 
 absl::StatusOr<RefCountedPtr<grpc_channel_stack>>
 ChannelStackBuilderImpl::Build() {
-  std::vector<const grpc_channel_filter*> stack;
-
-  for (const auto* filter : this->stack()) {
-    stack.push_back(filter);
-  }
+  std::vector<FilterAndConfig> stack = this->stack();
 
   // calculate the size of the channel stack
-  size_t channel_stack_size =
-      grpc_channel_stack_size(stack.data(), stack.size());
+  size_t channel_stack_size = grpc_channel_stack_size(stack);
 
   // allocate memory
   auto* channel_stack =
       static_cast<grpc_channel_stack*>(gpr_zalloc(channel_stack_size));
+  channel_stack->type = this->channel_stack_type();
 
   // and initialize it
   grpc_error_handle error = grpc_channel_stack_init(
@@ -74,8 +70,7 @@ ChannelStackBuilderImpl::Build() {
         grpc_channel_stack_destroy(stk);
         gpr_free(stk);
       },
-      channel_stack, stack.data(), stack.size(), channel_args(), name(),
-      channel_stack, blackboard_);
+      channel_stack, stack, channel_args(), name(), channel_stack, blackboard_);
 
   if (!error.ok()) {
     grpc_channel_stack_destroy(channel_stack);

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

@@ -17,10 +17,10 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "absl/status/statusor.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "absl/status/statusor.h"
 
 namespace grpc_core {
 

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

@@ -31,9 +31,6 @@
 #include <type_traits>
 #include <utility>
 
-#include "absl/log/check.h"
-#include "absl/status/status.h"
-#include "absl/status/statusor.h"
 #include "src/core/call/call_finalization.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/config/core_configuration.h"
@@ -71,9 +68,12 @@
 #include "src/core/lib/transport/transport.h"
 #include "src/core/util/alloc.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/time.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
 
 typedef struct connected_channel_channel_data {
   grpc_core::Transport* transport;
@@ -220,7 +220,7 @@ static void connected_channel_destroy_call_elem(
 static grpc_error_handle connected_channel_init_channel_elem(
     grpc_channel_element* elem, grpc_channel_element_args* args) {
   channel_data* cd = static_cast<channel_data*>(elem->channel_data);
-  CHECK(args->is_last);
+  GRPC_CHECK(args->is_last);
   cd->transport = args->channel_args.GetObject<grpc_core::Transport>();
   return absl::OkStatus();
 }