grpc 1.83.1 → 1.84.0

data/src/core/lib/surface/call.cc

@@ -356,9 +356,7 @@ void Call::HandleCompressionAlgorithmDisabled(
   std::string error_msg =
       absl::StrFormat("Compression algorithm '%s' is disabled.", algo_name);
   LOG(ERROR) << error_msg;
-  CancelWithError(grpc_error_set_int(absl::UnimplementedError(error_msg),
-                                     StatusIntProperty::kRpcStatus,
-                                     GRPC_STATUS_UNIMPLEMENTED));
+  CancelWithError(absl::UnimplementedError(error_msg));
 }
 
 grpc_error_handle Call::UpdateDeadline(Timestamp deadline) {
@@ -369,9 +367,7 @@ grpc_error_handle Call::UpdateDeadline(Timestamp deadline) {
   if (deadline >= deadline_) return absl::OkStatus();
   if (deadline < Timestamp::Now()) {
     lock.Release();
-    grpc_error_handle error = grpc_error_set_int(
-        absl::DeadlineExceededError("Deadline Exceeded"),
-        StatusIntProperty::kRpcStatus, GRPC_STATUS_DEADLINE_EXCEEDED);
+    grpc_error_handle error = absl::DeadlineExceededError("Deadline Exceeded");
     CancelWithError(error);
     return error;
   }
@@ -405,9 +401,7 @@ void Call::Run() {
   GRPC_TRACE_LOG(call, INFO)
       << "call deadline expired "
       << GRPC_DUMP_ARGS(Timestamp::Now(), send_deadline_);
-  CancelWithError(grpc_error_set_int(
-      absl::DeadlineExceededError("Deadline Exceeded"),
-      StatusIntProperty::kRpcStatus, GRPC_STATUS_DEADLINE_EXCEEDED));
+  CancelWithError(absl::DeadlineExceededError("Deadline Exceeded"));
   InternalUnref("deadline[run]");
 }
 

data/src/core/lib/surface/call_utils.h

@@ -58,6 +58,7 @@
 #include "src/core/lib/surface/completion_queue.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/grpc_check.h"
+#include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/upb_utils.h"
 #include "src/proto/grpc/channelz/v2/promise.upb.h"
 #include "upb/mem/arena.h"
@@ -584,6 +585,118 @@ class MessageReceiver {
       GRPC_COMPRESS_NONE;
 };
 
+// Tracks and validates the state of operations on a call to ensure invariants.
+//
+// Invariants validated:
+// 1. Intra-batch duplicates: A single batch cannot contain multiple operations
+//    of the same type.
+// 2. Once-only operations: Operations like sending initial metadata or closing
+//    the call can only be performed once.
+// 3. Concurrent operations: Operations like sending or receiving messages
+//    cannot run concurrently (i.e., a new one cannot start until the previous
+//    one completes).
+//
+// This class is thread-safe.
+class CallOpInvariantsValidator {
+ public:
+  CallOpInvariantsValidator() = default;
+
+  // Validates a batch of operations against the current call state and commits
+  // them if valid.
+  //
+  // Returns GRPC_CALL_OK if the batch is valid and its operations are
+  // successfully committed to the active state.
+  // Returns GRPC_CALL_ERROR_TOO_MANY_OPERATIONS if:
+  // - The batch contains duplicate operations of the same type.
+  // - Any operation in the batch conflicts with the current state (either
+  //   because a once-only operation has already been performed, or a
+  //   concurrent operation is already active).
+  grpc_call_error ValidateAndCommit(const grpc_op* ops, size_t nops) {
+    if (!IsCallv3BatchValidationEnabled()) {
+      return GRPC_CALL_OK;
+    }
+
+    uint8_t batch_ops = 0;
+    for (size_t i = 0; i < nops; i++) {
+      uint8_t op_bit = OpBit(ops[i].op);
+      // Detect intra-batch duplicate operations!
+      if ((batch_ops & op_bit) != 0) {
+        return GRPC_CALL_ERROR_TOO_MANY_OPERATIONS;
+      }
+      batch_ops |= op_bit;
+    }
+
+    uint8_t current_state = ops_state_.load(std::memory_order_relaxed);
+    while (true) {
+      if ((current_state & batch_ops) != 0) {
+        return GRPC_CALL_ERROR_TOO_MANY_OPERATIONS;
+      }
+      if (ops_state_.compare_exchange_weak(
+              current_state, current_state | batch_ops,
+              std::memory_order_relaxed, std::memory_order_relaxed)) {
+        return GRPC_CALL_OK;
+      }
+    }
+  }
+
+  // Resets the state of a concurrent operation, marking it as no longer active.
+  // This allows subsequent operations of the same type to be validated and
+  // committed. Should be called when the operation completes.
+  void ResetConcurrentOps(uint8_t ops_mask) {
+    if (ops_mask == 0 || !IsCallv3BatchValidationEnabled()) {
+      return;
+    }
+    GRPC_DCHECK((ops_mask & kConcurrentOpsMask) != 0);
+    GRPC_DCHECK((ops_mask & kOnceOpsMask) == 0);
+    ops_state_.fetch_and(~ops_mask, std::memory_order_relaxed);
+  }
+
+  static constexpr uint8_t OpBit(const grpc_op_type op) { return 1 << op; }
+
+ private:
+  static constexpr uint8_t kOnceOpsMask =
+      (1 << GRPC_OP_SEND_INITIAL_METADATA) |
+      (1 << GRPC_OP_SEND_CLOSE_FROM_CLIENT) |
+      (1 << GRPC_OP_SEND_STATUS_FROM_SERVER) |
+      (1 << GRPC_OP_RECV_INITIAL_METADATA) |
+      (1 << GRPC_OP_RECV_STATUS_ON_CLIENT) |
+      (1 << GRPC_OP_RECV_CLOSE_ON_SERVER);
+
+  static constexpr uint8_t kConcurrentOpsMask =
+      (1 << GRPC_OP_SEND_MESSAGE) | (1 << GRPC_OP_RECV_MESSAGE);
+
+  std::atomic<uint8_t> ops_state_{0};
+};
+
+// Helper class to perform cleanup of primary ops for both ClientCall and
+// ServerCall.
+template <typename CallType>
+class PrimaryOpsCleanup {
+ public:
+  explicit PrimaryOpsCleanup(WeakRefCountedPtr<CallType> self,
+                             uint8_t concurrent_ops_to_reset)
+      : self_(std::move(self)),
+        concurrent_ops_to_reset_(concurrent_ops_to_reset) {}
+
+  // PrimaryOpsCleanup is move only.
+  PrimaryOpsCleanup(const PrimaryOpsCleanup&) = delete;
+  PrimaryOpsCleanup& operator=(const PrimaryOpsCleanup&) = delete;
+  PrimaryOpsCleanup(PrimaryOpsCleanup&&) = default;
+  PrimaryOpsCleanup& operator=(PrimaryOpsCleanup&&) = default;
+
+  ~PrimaryOpsCleanup() {
+    if (concurrent_ops_to_reset_ == 0) return;
+    if (self_ != nullptr) {
+      self_->call_op_invariants_validator_.ResetConcurrentOps(
+          concurrent_ops_to_reset_);
+    }
+  }
+
+ private:
+  WeakRefCountedPtr<CallType> self_;
+  uint8_t concurrent_ops_to_reset_;
+};
+
 std::string MakeErrorString(const ServerMetadata* trailing_metadata);
 
 }  // namespace grpc_core

data/src/core/lib/surface/channel_create.cc

@@ -104,7 +104,7 @@ absl::StatusOr<RefCountedPtr<Channel>> ChannelCreate(
     case GRPC_CLIENT_CHANNEL:
       return ClientChannel::Create(std::move(target), std::move(args));
     case GRPC_CLIENT_DIRECT_CHANNEL:
-      return DirectChannel::Create(std::move(target), args);
+      return DirectChannel::Create(std::move(target), std::move(args));
     default:
       Crash(absl::StrCat("Invalid channel stack type for ChannelCreate: ",
                          grpc_channel_stack_type_string(channel_stack_type)));

data/src/core/lib/surface/channel_create.h

@@ -26,8 +26,6 @@
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "absl/status/statusor.h"
 
-#define GRPC_ARG_USE_V3_STACK "grpc.internal.use_v3_stack"
-
 namespace grpc_core {
 
 class Transport;

data/src/core/lib/surface/channel_init.cc

@@ -33,6 +33,7 @@
 #include "src/core/channelz/channelz.h"
 #include "src/core/channelz/property_list.h"
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/grpc_check.h"
@@ -48,13 +49,6 @@ namespace grpc_core {
 UniqueTypeName (*NameFromChannelFilter)(const grpc_channel_filter*);
 
 namespace {
-struct CompareChannelFiltersByName {
-  bool operator()(UniqueTypeName a, UniqueTypeName b) const {
-    // Compare lexicographically instead of by pointer value so that different
-    // builds make the same choices.
-    return a.name() < b.name();
-  }
-};
 
 struct CompareFusedChannelFiltersByName {
   bool operator()(ChannelInit::FilterRegistration* a,
@@ -111,12 +105,12 @@ ChannelInit::FilterRegistration& ChannelInit::FilterRegistration::IfNot(
 }
 
 ChannelInit::FilterRegistration&
-ChannelInit::FilterRegistration::IfHasChannelArg(const char* arg) {
+ChannelInit::FilterRegistration::IfHasChannelArg(absl::string_view arg) {
   return If([arg](const ChannelArgs& args) { return args.Contains(arg); });
 }
 
 ChannelInit::FilterRegistration& ChannelInit::FilterRegistration::IfChannelArg(
-    const char* arg, bool default_value) {
+    absl::string_view arg, bool default_value) {
   return If([arg, default_value](const ChannelArgs& args) {
     return args.GetBool(arg).value_or(default_value);
   });
@@ -126,6 +120,12 @@ ChannelInit::FilterRegistration&
 ChannelInit::FilterRegistration::ExcludeFromMinimalStack() {
   return If([](const ChannelArgs& args) { return !args.WantMinimalStack(); });
 }
+ChannelInit::Builder::Builder()
+    : fix_v3_filter_stack_server_side_ordering_(
+          IsFixV3FilterStackServerSideOrderingEnabled()) {}
+ChannelInit::Builder::Builder(bool fix_v3_filter_stack_server_side_ordering)
+    : fix_v3_filter_stack_server_side_ordering_(
+          fix_v3_filter_stack_server_side_ordering) {}
 
 ChannelInit::FilterRegistration& ChannelInit::Builder::RegisterFilter(
     grpc_channel_stack_type type, UniqueTypeName name,
@@ -146,32 +146,23 @@ void ChannelInit::Builder::RegisterFusedFilter(
 
 class ChannelInit::DependencyTracker {
  public:
+  explicit DependencyTracker(bool reverse_ordering_)
+      : ready_dependencies_(ReadyDependency::Comparator{reverse_ordering_}),
+        reverse_ordering_(reverse_ordering_) {}
+
   // Declare that a filter exists.
   void Declare(FilterRegistration* registration) {
     nodes_.emplace(registration->name_, registration);
   }
   // Insert an edge from a to b
   // Both nodes must be declared.
+
   void InsertEdge(UniqueTypeName a, UniqueTypeName b) {
-    auto it_a = nodes_.find(a);
-    auto it_b = nodes_.find(b);
-    if (it_a == nodes_.end()) {
-      GRPC_TRACE_LOG(channel_stack, INFO)
-          << "gRPC Filter " << a.name()
-          << " was not declared before adding an edge to " << b.name();
-      return;
-    }
-    if (it_b == nodes_.end()) {
-      GRPC_TRACE_LOG(channel_stack, INFO)
-          << "gRPC Filter " << b.name()
-          << " was not declared before adding an edge from " << a.name();
-      return;
+    if (!reverse_ordering_) {
+      InsertEdgeImpl(a, b);
+    } else {
+      InsertEdgeImpl(b, a);
     }
-    auto& node_a = it_a->second;
-    auto& node_b = it_b->second;
-    node_a.dependents.push_back(&node_b);
-    node_b.all_dependencies.push_back(a);
-    ++node_b.waiting_dependencies;
   }
 
   // Finish the dependency graph and begin iteration.
@@ -247,21 +238,61 @@ class ChannelInit::DependencyTracker {
     Ordering ordering() const { return registration->ordering_; }
     absl::string_view name() const { return registration->name_.name(); }
   };
+
   struct ReadyDependency {
     explicit ReadyDependency(Node* node) : node(node) {}
     Node* node;
-    bool operator<(const ReadyDependency& other) const {
+
+    struct Comparator {
       // Sort first on ordering, and then lexically on name.
       // The lexical sort means that the ordering is stable between builds
       // (UniqueTypeName ordering is not stable between builds).
-      return node->ordering() > other.node->ordering() ||
-             (node->ordering() == other.node->ordering() &&
-              node->name() > other.node->name());
-    }
+      bool operator()(const ReadyDependency& a,
+                      const ReadyDependency& b) const {
+        if (!reverse_ordering) {
+          return a.node->ordering() > b.node->ordering() ||
+                 (a.node->ordering() == b.node->ordering() &&
+                  a.node->name() > b.node->name());
+        } else {
+          return a.node->ordering() < b.node->ordering() ||
+                 (a.node->ordering() == b.node->ordering() &&
+                  a.node->name() > b.node->name());
+        }
+      };
+      bool reverse_ordering = false;
+    };
   };
+
+  void InsertEdgeImpl(UniqueTypeName a, UniqueTypeName b) {
+    auto it_a = nodes_.find(a);
+    auto it_b = nodes_.find(b);
+    if (it_a == nodes_.end()) {
+      GRPC_TRACE_LOG(channel_stack, INFO)
+          << "gRPC Filter " << a.name()
+          << " was not declared before adding an edge to " << b.name();
+      return;
+    }
+    if (it_b == nodes_.end()) {
+      GRPC_TRACE_LOG(channel_stack, INFO)
+          << "gRPC Filter " << b.name()
+          << " was not declared before adding an edge from " << a.name();
+      return;
+    }
+    auto& node_a = it_a->second;
+    auto& node_b = it_b->second;
+    node_a.dependents.push_back(&node_b);
+    node_b.all_dependencies.push_back(a);
+    ++node_b.waiting_dependencies;
+  }
+
   absl::flat_hash_map<UniqueTypeName, Node> nodes_;
-  std::priority_queue<ReadyDependency> ready_dependencies_;
+  std::priority_queue<ReadyDependency, std::vector<ReadyDependency>,
+                      ReadyDependency::Comparator>
+      ready_dependencies_;
   size_t nodes_taken_ = 0;
+
+  // Whether to reverse the ordering for server side filters.
+  bool reverse_ordering_ = false;
 };
 
 template <bool is_terminal>
@@ -333,14 +364,17 @@ std::tuple<std::vector<ChannelInit::Filter>, std::vector<ChannelInit::Filter>>
 ChannelInit::SortFilterRegistrationsByDependencies(
     const std::vector<std::unique_ptr<ChannelInit::FilterRegistration>>&
         filter_registrations,
-    grpc_channel_stack_type type, channelz::PropertyTable& filter_ordering) {
+    grpc_channel_stack_type type, channelz::PropertyTable& filter_ordering,
+    bool fix_v3_filter_stack_server_side_ordering) {
   // Phase 1: Build a map from filter to the set of filters that must be
   // initialized before it.
   // We order this map (and the set of dependent filters) by filter name to
   // ensure algorithm ordering stability is deterministic for a given build.
   // We should not require this, but at the time of writing it's expected that
   // this will help overall stability.
-  DependencyTracker dependencies;
+  const bool reverse_ordering = !grpc_channel_stack_type_is_client(type) &&
+                                fix_v3_filter_stack_server_side_ordering;
+  DependencyTracker dependencies{reverse_ordering};
   std::vector<Filter> terminal_filters;
   for (const auto& registration : filter_registrations) {
     if (registration->terminal_) {
@@ -432,7 +466,8 @@ ChannelInit::StackConfig ChannelInit::BuildStackConfig(
         filter_registrations,
     const std::vector<std::unique_ptr<ChannelInit::FilterRegistration>>&
         fused_filter_registrations,
-    PostProcessor* post_processors, grpc_channel_stack_type type) {
+    PostProcessor* post_processors, grpc_channel_stack_type type,
+    bool fix_v3_filter_stack_server_side_ordering) {
   // Collect post processors that need to be applied.
   // We've already ensured the one-per-slot constraint, so now we can just
   // collect everything up into a vector and run it in order.
@@ -444,7 +479,8 @@ ChannelInit::StackConfig ChannelInit::BuildStackConfig(
   channelz::PropertyTable filter_ordering;
 
   auto sorted_filters = SortFilterRegistrationsByDependencies(
-      filter_registrations, type, filter_ordering);
+      filter_registrations, type, filter_ordering,
+      fix_v3_filter_stack_server_side_ordering);
   std::vector<Filter> filters = std::move(std::get<0>(sorted_filters));
   std::vector<Filter> terminal_filters = std::move(std::get<1>(sorted_filters));
 
@@ -563,10 +599,13 @@ void ChannelInit::PrintChannelStackTrace(
 
 ChannelInit ChannelInit::Builder::Build() {
   ChannelInit result;
+  result.fix_v3_filter_stack_server_side_ordering_ =
+      fix_v3_filter_stack_server_side_ordering_;
   for (int i = 0; i < GRPC_NUM_CHANNEL_STACK_TYPES; i++) {
     result.stack_configs_[i] =
         BuildStackConfig(filters_[i], fused_filters_[i], post_processors_[i],
-                         static_cast<grpc_channel_stack_type>(i));
+                         static_cast<grpc_channel_stack_type>(i),
+                         fix_v3_filter_stack_server_side_ordering_);
   }
   return result;
 }

data/src/core/lib/surface/channel_init.h

@@ -73,6 +73,7 @@ class ChannelInit {
     kV2,
     kV3,
   };
+
   static const char* VersionToString(Version version) {
     switch (version) {
       case Version::kAny:
@@ -127,6 +128,7 @@ class ChannelInit {
     kXdsChannelStackModifier,
     kCount
   };
+
   static const char* PostProcessorSlotName(PostProcessorSlot slot) {
     switch (slot) {
       case PostProcessorSlot::kAuthSubstitution:
@@ -224,10 +226,10 @@ class ChannelInit {
     FilterRegistration& IfNot(InclusionPredicate predicate);
     // Add a predicate that only includes this filter if a channel arg is
     // present.
-    FilterRegistration& IfHasChannelArg(const char* arg);
+    FilterRegistration& IfHasChannelArg(absl::string_view arg);
     // Add a predicate that only includes this filter if a boolean channel arg
     // is true (with default_value being used if the argument is not present).
-    FilterRegistration& IfChannelArg(const char* arg, bool default_value);
+    FilterRegistration& IfChannelArg(absl::string_view arg, bool default_value);
     // Mark this filter as being terminal.
     // Exactly one terminal filter will be added at the end of each filter
     // stack.
@@ -301,17 +303,10 @@ class ChannelInit {
 
   class Builder {
    public:
-    // Register a builder in the normal filter registration pass.
-    // This occurs first during channel build time.
-    // The FilterRegistration methods can be called to declaratively define
-    // properties of the filter being registered.
-    // TODO(ctiller): remove in favor of the version that does not mention
-    // grpc_channel_filter
-    FilterRegistration& RegisterFilter(grpc_channel_stack_type type,
-                                       UniqueTypeName name,
-                                       const grpc_channel_filter* filter,
-                                       FilterAdder filter_adder = nullptr,
-                                       SourceLocation registration_source = {});
+    Builder();
+
+    // TEST ONLY.
+    explicit Builder(bool fix_v3_filter_stack_server_side_ordering);
     FilterRegistration& RegisterFilter(
         grpc_channel_stack_type type, const grpc_channel_filter* filter,
         SourceLocation registration_source = {}) {
@@ -319,6 +314,7 @@ class ChannelInit {
       return RegisterFilter(type, NameFromChannelFilter(filter), filter,
                             nullptr, registration_source);
     }
+
     template <typename Filter>
     FilterRegistration& RegisterFilter(
         grpc_channel_stack_type type, SourceLocation registration_source = {}) {
@@ -383,12 +379,27 @@ class ChannelInit {
     ChannelInit Build();
 
    private:
+    // Register a builder in the normal filter registration pass.
+    // This occurs first during channel build time.
+    // The FilterRegistration methods can be called to declaratively define
+    // properties of the filter being registered.
+    // TODO(ctiller): remove in favor of the version that does not mention
+    // grpc_channel_filter
+    FilterRegistration& RegisterFilter(grpc_channel_stack_type type,
+                                       UniqueTypeName name,
+                                       const grpc_channel_filter* filter,
+                                       FilterAdder filter_adder = nullptr,
+                                       SourceLocation registration_source = {});
+
     std::vector<std::unique_ptr<FilterRegistration>>
         filters_[GRPC_NUM_CHANNEL_STACK_TYPES];
     std::vector<std::unique_ptr<FilterRegistration>>
         fused_filters_[GRPC_NUM_CHANNEL_STACK_TYPES];
     PostProcessor post_processors_[GRPC_NUM_CHANNEL_STACK_TYPES]
                                   [static_cast<int>(PostProcessorSlot::kCount)];
+    // TODO(weizheyuan): Remove this once the corresponding experiment
+    // `fix_v3_filter_stack_server_side_ordering` is deleted.
+    bool fix_v3_filter_stack_server_side_ordering_ = false;
   };
 
   /// Construct a channel stack of some sort: see channel_stack.h for details
@@ -445,19 +456,21 @@ class ChannelInit {
   };
 
   StackConfig stack_configs_[GRPC_NUM_CHANNEL_STACK_TYPES];
+  bool fix_v3_filter_stack_server_side_ordering_ = false;
 
   static std::tuple<std::vector<Filter>, std::vector<Filter>>
   SortFilterRegistrationsByDependencies(
       const std::vector<std::unique_ptr<FilterRegistration>>&
           filter_registrations,
-      grpc_channel_stack_type type, channelz::PropertyTable& filter_ordering);
+      grpc_channel_stack_type type, channelz::PropertyTable& filter_ordering,
+      bool fix_v3_filter_stack_server_side_ordering);
 
   static std::vector<Filter> SortFusedFilterRegistrations(
       const std::vector<std::unique_ptr<FilterRegistration>>&
           filter_registrations);
 
   template <bool is_terminal>
-  static std::vector<FilterNode> SelectFiltersByPredicate(
+  static std::vector<ChannelInit::FilterNode> SelectFiltersByPredicate(
       const std::vector<Filter>& filters, ChannelStackBuilder* builder);
 
   static void MergeFusedFilters(ChannelStackBuilder* builder,
@@ -471,7 +484,8 @@ class ChannelInit {
           filter_registrations,
       const std::vector<std::unique_ptr<FilterRegistration>>&
           fused_filter_registrations,
-      PostProcessor* post_processors, grpc_channel_stack_type type);
+      PostProcessor* post_processors, grpc_channel_stack_type type,
+      bool fix_v3_filter_stack_server_side_ordering);
 
   static void PrintChannelStackTrace(
       grpc_channel_stack_type type,

data/src/core/lib/surface/filter_stack_call.cc

@@ -137,8 +137,7 @@ grpc_error_handle FilterStackCall::Create(grpc_call_create_args* args,
         GrpcRegisteredMethod(), reinterpret_cast<void*>(static_cast<uintptr_t>(
                                     args->registered_method)));
     if (parent != nullptr) {
-      add_init_error(&error, absl_status_to_grpc_error(call->InitParent(
-                                 parent, args->propagation_mask)));
+      add_init_error(&error, call->InitParent(parent, args->propagation_mask));
     }
     // Client call tracers should be created after propagating relevant
     // properties (tracing included) from the parent.
@@ -470,9 +469,7 @@ void FilterStackCall::RecvTrailingFilter(grpc_metadata_batch* b,
       SetFinalStatus(absl::OkStatus());
     } else {
       VLOG(2) << "Received trailing metadata with no error and no status";
-      SetFinalStatus(grpc_error_set_int(GRPC_ERROR_CREATE("No status received"),
-                                        StatusIntProperty::kRpcStatus,
-                                        GRPC_STATUS_UNKNOWN));
+      SetFinalStatus(absl::UnknownError("No status received"));
     }
   }
   PublishAppMetadata(b, true);
@@ -899,11 +896,9 @@ grpc_call_error FilterStackCall::StartBatch(const grpc_op* ops, size_t nops,
         grpc_error_handle status_error =
             op->data.send_status_from_server.status == GRPC_STATUS_OK
                 ? absl::OkStatus()
-                : grpc_error_set_int(
-                      GRPC_ERROR_CREATE("Server returned error"),
-                      StatusIntProperty::kRpcStatus,
-                      static_cast<intptr_t>(
-                          op->data.send_status_from_server.status));
+                : absl::Status(static_cast<absl::StatusCode>(
+                                   op->data.send_status_from_server.status),
+                               "Server returned error");
         if (op->data.send_status_from_server.status_details != nullptr) {
           send_trailing_metadata_.Set(
               GrpcMessageMetadata(),

data/src/core/lib/surface/init.cc

@@ -46,14 +46,10 @@
 #include "src/core/util/thd.h"
 #include "absl/base/thread_annotations.h"
 #include "absl/log/log.h"
+#include "absl/random/random.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
 
-// Remnants of the old plugin system
-void grpc_resolver_dns_ares_init(void);
-void grpc_resolver_dns_ares_shutdown(void);
-void grpc_resolver_dns_ares_reset_dns_resolver(void);
-
 extern absl::Status AresInit();
 extern void AresShutdown();
 
@@ -80,10 +76,15 @@ void RegisterSecurityFilters(CoreConfiguration::Builder* builder) {
   builder->channel_init()
       ->RegisterFilter<ServerAuthFilter>(GRPC_SERVER_CHANNEL)
       .IfHasChannelArg(GRPC_SERVER_CREDENTIALS_ARG);
-  builder->channel_init()
-      ->RegisterFilter<GrpcServerAuthzFilter>(GRPC_SERVER_CHANNEL)
-      .IfHasChannelArg(GRPC_ARG_AUTHORIZATION_POLICY_PROVIDER)
-      .After<ServerAuthFilter>();
+  auto& authz_registration =
+      builder->channel_init()
+          ->RegisterFilter<GrpcServerAuthzFilter>(GRPC_SERVER_CHANNEL)
+          .IfHasChannelArg(GRPC_ARG_AUTHORIZATION_POLICY_PROVIDER);
+  if (IsFixV3FilterStackServerSideOrderingEnabled()) {
+    authz_registration.Before<ServerAuthFilter>();
+  } else {
+    authz_registration.After<ServerAuthFilter>();
+  }
 }
 }  // namespace grpc_core
 
@@ -102,6 +103,9 @@ static void do_basic_init(void) {
   grpc_fork_handlers_auto_register();
   grpc_tracer_init();
   grpc_client_channel_global_init_backup_polling();
+  // Pre-warm Abseil random entropy pool while file descriptors are available,
+  // preventing late-runtime SeedGenException crashes under FD exhaustion.
+  (void)absl::InsecureBitGen()();
 }
 
 void grpc_init(void) {
@@ -114,18 +118,6 @@ void grpc_init(void) {
       g_shutting_down_cv->SignalAll();
     }
     grpc_iomgr_init();
-    if (grpc_core::IsEventEngineDnsEnabled()) {
-      address_sorting_init();
-      auto status = AresInit();
-      if (!status.ok()) {
-        VLOG(2) << "AresInit failed: " << status.message();
-      } else {
-        // TODO(yijiem): remove this once we remove the iomgr dns system.
-        grpc_resolver_dns_ares_reset_dns_resolver();
-      }
-    } else {
-      grpc_resolver_dns_ares_init();
-    }
     grpc_iomgr_start();
   }
 
@@ -138,12 +130,6 @@ void grpc_shutdown_internal_locked(void)
     grpc_core::ExecCtx exec_ctx(0);
     grpc_iomgr_shutdown_background_closure();
     grpc_timer_manager_set_threading(false);  // shutdown timer_manager thread
-    if (grpc_core::IsEventEngineDnsEnabled()) {
-      address_sorting_shutdown();
-      AresShutdown();
-    } else {
-      grpc_resolver_dns_ares_shutdown();
-    }
     grpc_iomgr_shutdown();
   }
   g_shutting_down = false;

data/src/core/lib/surface/version.cc

@@ -24,4 +24,4 @@
 
 const char* grpc_version_string(void) { return "56.0.0"; }
 
-const char* grpc_g_stands_for(void) { return "garden"; }
+const char* grpc_g_stands_for(void) { return "gimbal"; }

data/src/core/lib/transport/error_utils.cc

@@ -30,21 +30,6 @@
 
 using grpc_core::http2::Http2ErrorCode;
 
-static grpc_error_handle recursively_find_error_with_field(
-    grpc_error_handle error, grpc_core::StatusIntProperty which) {
-  intptr_t unused;
-  // If the error itself has a status code, return it.
-  if (grpc_error_get_int(error, which, &unused)) {
-    return error;
-  }
-  std::vector<absl::Status> children = grpc_core::StatusGetChildren(error);
-  for (const absl::Status& child : children) {
-    grpc_error_handle result = recursively_find_error_with_field(child, which);
-    if (!result.ok()) return result;
-  }
-  return absl::OkStatus();
-}
-
 namespace {
 
 std::optional<Http2ErrorCode> GetHttp2Error(const absl::Status& status) {
@@ -95,15 +80,3 @@ void grpc_error_get_status(grpc_error_handle error,
     }
   }
 }
-
-absl::Status grpc_error_to_absl_status(grpc_error_handle error) {
-  return error;
-}
-
-grpc_error_handle absl_status_to_grpc_error(absl::Status status) {
-  return status;
-}
-
-bool grpc_error_has_clear_grpc_status(grpc_error_handle error) {
-  return error.code() != absl::StatusCode::kUnknown;
-}