grpc 1.80.0 → 1.81.0

data/src/core/lib/promise/sleep.cc

@@ -37,12 +37,10 @@ Sleep::~Sleep() {
 }
 
 Poll<absl::Status> Sleep::operator()() {
-  if (!IsSleepPromiseExecCtxRemovalEnabled()) {
-    // Invalidate now so that we see a fresh version of the time.
-    // TODO(ctiller): the following can be safely removed when we remove
-    // ExecCtx.
-    ExecCtx::Get()->InvalidateNow();
-  }
+  // Invalidate now so that we see a fresh version of the time.
+  // TODO(akshitpatel): the following can be safely removed when we remove
+  // ExecCtx.
+  ExecCtx::Get()->InvalidateNow();
   const auto now = Timestamp::Now();
   // If the deadline is earlier than now we can just return.
   if (deadline_ <= now) return absl::OkStatus();
@@ -56,9 +54,7 @@ Poll<absl::Status> Sleep::operator()() {
 }
 
 Sleep::ActiveClosure::ActiveClosure(Timestamp deadline)
-    : waker_((IsSleepUseNonOwningWakerEnabled())
-                 ? GetContext<Activity>()->MakeNonOwningWaker()
-                 : GetContext<Activity>()->MakeOwningWaker()),
+    : waker_(GetContext<Activity>()->MakeNonOwningWaker()),
       event_engine_(GetContext<EventEngine>()->shared_from_this()),
       timer_handle_(
           event_engine_->RunAfter(deadline - Timestamp::Now(), this)) {}

data/src/core/lib/resource_quota/arena.h

@@ -494,7 +494,7 @@ inline void UnrefDestroy::operator()(const Arena* arena) const {
 namespace promise_detail {
 
 template <typename T>
-class Context<T, absl::void_t<decltype(ArenaContextType<T>::Destroy)>> {
+class Context<T, std::void_t<decltype(ArenaContextType<T>::Destroy)>> {
  public:
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static T* get() {
     return GetContext<Arena>()->GetContext<T>();

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

@@ -77,6 +77,7 @@
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/call_test_only.h"
+#include "src/core/lib/surface/call_utils.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/completion_queue.h"
 #include "src/core/lib/surface/validate_metadata.h"
@@ -507,7 +508,27 @@ grpc_call_error grpc_call_start_batch(grpc_call* call, const grpc_op* ops,
     return GRPC_CALL_ERROR;
   } else {
     grpc_core::ExecCtx exec_ctx;
-    return grpc_core::Call::FromC(call)->StartBatch(ops, nops, tag, false);
+    grpc_core::Call* call_obj = grpc_core::Call::FromC(call);
+    grpc_call_error err = call_obj->StartBatch(ops, nops, tag, false);
+    // Capturing invalid metadata error and cancelling RPC rather than failing
+    // the batch which causes crash.
+    if (err == GRPC_CALL_ERROR_INVALID_METADATA) {
+      // Convert the validation error into a failed RPC
+      call_obj->CancelWithStatus(GRPC_STATUS_INTERNAL, "Invalid metadata");
+      // Pre-fill receive op output buffers to safe error-state values.
+      // done_with_error rolled back all state so these ops were never
+      // registered with the transport — CancelWithStatus will not fill them.
+      // Needed because language wrappers (e.g. Python) read output fields
+      // regardless of the success flag in the CQ completion.
+      grpc_core::PreFillReceiveOpsForInvalidMetadata(ops, nops);
+      // Post a failed completion directly via the proper API — does not go
+      // through StartBatch so does not depend on nops==0 handling, and
+      // correctly surfaces success=false to the application.
+      call_obj->FailBatchImmediately(tag, false,
+                                     GRPC_ERROR_CREATE("Invalid metadata"));
+      return GRPC_CALL_OK;
+    }
+    return err;
   }
 }
 
@@ -515,7 +536,18 @@ grpc_call_error grpc_call_start_batch_and_execute(grpc_call* call,
                                                   const grpc_op* ops,
                                                   size_t nops,
                                                   grpc_closure* closure) {
-  return grpc_core::Call::FromC(call)->StartBatch(ops, nops, closure, true);
+  grpc_core::Call* call_obj = grpc_core::Call::FromC(call);
+  grpc_call_error err = call_obj->StartBatch(ops, nops, closure, true);
+  if (err == GRPC_CALL_ERROR_INVALID_METADATA) {
+    call_obj->CancelWithStatus(GRPC_STATUS_INTERNAL, "Invalid metadata");
+    // No output buffer pre-fill here: internal callers using this function
+    // handle errors via the closure's error parameter, not by reading op
+    // output fields directly.
+    call_obj->FailBatchImmediately(closure, true,
+                                   GRPC_ERROR_CREATE("Invalid metadata"));
+    return GRPC_CALL_OK;
+  }
+  return err;
 }
 
 void grpc_call_tracer_set(grpc_call* call,
@@ -602,10 +634,15 @@ const char* grpc_call_error_to_string(grpc_call_error error) {
 
 void grpc_call_run_in_event_engine(const grpc_call* call,
                                    absl::AnyInvocable<void()> cb) {
-  grpc_core::Call::FromC(call)
-      ->arena()
-      ->GetContext<grpc_event_engine::experimental::EventEngine>()
-      ->Run(std::move(cb));
+  if (call == nullptr) {
+    grpc_event_engine::experimental::GetDefaultEventEngine()->Run(
+        std::move(cb));
+  } else {
+    grpc_core::Call::FromC(call)
+        ->arena()
+        ->GetContext<grpc_event_engine::experimental::EventEngine>()
+        ->Run(std::move(cb));
+  }
 }
 
 void grpc_call_run_cq_cb(const grpc_call* call,

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

@@ -98,6 +98,12 @@ class Call : public CppImplOf<Call, grpc_call>,
   virtual grpc_call_error StartBatch(const grpc_op* ops, size_t nops,
                                      void* notify_tag,
                                      bool is_notify_tag_closure) = 0;
+  // Posts an immediate failed completion for notify_tag without going through
+  // the transport. Used when a batch is rejected before any state is committed
+  // (e.g. invalid metadata), so the caller still receives a CQ event.
+  virtual void FailBatchImmediately(void* notify_tag,
+                                    bool is_notify_tag_closure,
+                                    grpc_error_handle error) = 0;
   virtual bool failed_before_recv_message() const = 0;
   virtual bool is_trailers_only() const = 0;
   virtual absl::string_view GetServerAuthority() const = 0;

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

@@ -213,18 +213,57 @@ bool ValidateMetadata(size_t count, grpc_metadata* metadata) {
 }
 
 void EndOpImmediately(grpc_completion_queue* cq, void* notify_tag,
-                      bool is_notify_tag_closure) {
+                      bool is_notify_tag_closure, grpc_error_handle error) {
   if (!is_notify_tag_closure) {
     GRPC_CHECK(grpc_cq_begin_op(cq, notify_tag));
     grpc_cq_end_op(
-        cq, notify_tag, absl::OkStatus(),
+        cq, notify_tag, std::move(error),
         [](void*, grpc_cq_completion* completion) { gpr_free(completion); },
         nullptr,
         static_cast<grpc_cq_completion*>(
             gpr_malloc(sizeof(grpc_cq_completion))));
   } else {
     Closure::Run(DEBUG_LOCATION, static_cast<grpc_closure*>(notify_tag),
-                 absl::OkStatus());
+                 std::move(error));
+  }
+}
+
+void PreFillReceiveOpsForInvalidMetadata(const grpc_op* ops, size_t nops) {
+  for (size_t i = 0; i < nops; ++i) {
+    switch (ops[i].op) {
+      case GRPC_OP_RECV_STATUS_ON_CLIENT:
+        if (ops[i].data.recv_status_on_client.status != nullptr) {
+          *ops[i].data.recv_status_on_client.status = GRPC_STATUS_INTERNAL;
+        }
+        if (ops[i].data.recv_status_on_client.status_details != nullptr) {
+          *ops[i].data.recv_status_on_client.status_details =
+              grpc_slice_from_static_string("Invalid metadata");
+        }
+        if (ops[i].data.recv_status_on_client.trailing_metadata != nullptr) {
+          grpc_metadata_array_init(
+              ops[i].data.recv_status_on_client.trailing_metadata);
+        }
+        break;
+      case GRPC_OP_RECV_CLOSE_ON_SERVER:
+        if (ops[i].data.recv_close_on_server.cancelled != nullptr) {
+          *ops[i].data.recv_close_on_server.cancelled = 1;
+        }
+        break;
+      case GRPC_OP_RECV_INITIAL_METADATA:
+        if (ops[i].data.recv_initial_metadata.recv_initial_metadata !=
+            nullptr) {
+          grpc_metadata_array_init(
+              ops[i].data.recv_initial_metadata.recv_initial_metadata);
+        }
+        break;
+      case GRPC_OP_RECV_MESSAGE:
+        if (ops[i].data.recv_message.recv_message != nullptr) {
+          *ops[i].data.recv_message.recv_message = nullptr;
+        }
+        break;
+      default:
+        break;
+    }
   }
 }
 

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

@@ -47,6 +47,7 @@
 #include "src/core/call/metadata_batch.h"
 #include "src/core/channelz/property_list.h"
 #include "src/core/lib/experiments/experiments.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/cancel_callback.h"
 #include "src/core/lib/promise/detail/promise_like.h"
@@ -151,8 +152,10 @@ void CToMetadata(grpc_metadata* metadata, size_t count, grpc_metadata_batch* b);
 const char* GrpcOpTypeName(grpc_op_type op);
 
 bool ValidateMetadata(size_t count, grpc_metadata* metadata);
+void PreFillReceiveOpsForInvalidMetadata(const grpc_op* ops, size_t nops);
 void EndOpImmediately(grpc_completion_queue* cq, void* notify_tag,
-                      bool is_notify_tag_closure);
+                      bool is_notify_tag_closure,
+                      grpc_error_handle error = absl::OkStatus());
 
 inline bool AreWriteFlagsValid(uint32_t flags) {
   // check that only bits in GRPC_WRITE_(INTERNAL?)_USED_MASK are set
@@ -401,6 +404,26 @@ class WaitForCqEndOp {
   }
 };
 
+inline void CompleteBatchOp(grpc_completion_queue* cq, void* notify_tag,
+                            bool is_notify_tag_closure, absl::Status&& status) {
+  // Notifies the upper layer that a Batch op is completed:
+  // - If notify_tag is a closure, executes it directly to propagate completion.
+  // - Otherwise, uses the completion queue (grpc_cq_end_op) to notify.
+  // Note: CommitBatch calls grpc_cq_begin_op() only if notify_tag is not a
+  // closure.
+  if (IsPromiseBatchCleanupOnCancelEnabled() && is_notify_tag_closure) {
+    EnsureRunInExecCtx([notify_tag, status = std::move(status)]() mutable {
+      ExecCtx::Run(DEBUG_LOCATION, static_cast<grpc_closure*>(notify_tag),
+                   std::move(status));
+    });
+  } else {
+    grpc_cq_end_op(
+        cq, notify_tag, std::forward<absl::Status>(status),
+        [](void*, grpc_cq_completion* completion) { delete completion; },
+        nullptr, new grpc_cq_completion);
+  }
+}
+
 template <typename FalliblePart, typename FinalPart>
 auto InfallibleBatch(FalliblePart&& fallible_part, FinalPart&& final_part,
                      bool is_notify_tag_closure, void* notify_tag,
@@ -422,11 +445,9 @@ auto InfallibleBatch(FalliblePart&& fallible_part, FinalPart&& final_part,
                                                         absl::OkStatus(), cq);
                                 }));
       },
-      [cq, notify_tag]() {
-        grpc_cq_end_op(
-            cq, notify_tag, absl::OkStatus(),
-            [](void*, grpc_cq_completion* completion) { delete completion; },
-            nullptr, new grpc_cq_completion);
+      [cq, notify_tag, is_notify_tag_closure]() {
+        CompleteBatchOp(cq, notify_tag, is_notify_tag_closure,
+                        absl::OkStatus());
       });
 }
 
@@ -448,11 +469,9 @@ auto FallibleBatch(FalliblePart&& fallible_part, bool is_notify_tag_closure,
                                         StatusCast<absl::Status>(r), cq);
                 }));
       },
-      [cq]() {
-        grpc_cq_end_op(
-            cq, nullptr, absl::CancelledError(),
-            [](void*, grpc_cq_completion* completion) { delete completion; },
-            nullptr, new grpc_cq_completion);
+      [cq, notify_tag, is_notify_tag_closure]() {
+        CompleteBatchOp(cq, notify_tag, is_notify_tag_closure,
+                        absl::CancelledError());
       });
 }
 

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

@@ -34,6 +34,10 @@ bool grpc_channel_stack_type_is_client(grpc_channel_stack_type type) {
       return true;
     case GRPC_SERVER_CHANNEL:
       return false;
+    case GRPC_CLIENT_VIRTUAL_CHANNEL:
+      return true;
+    case GRPC_SERVER_VIRTUAL_CHANNEL:
+      return false;
     case GRPC_NUM_CHANNEL_STACK_TYPES:
       break;
   }
@@ -54,6 +58,10 @@ const char* grpc_channel_stack_type_string(grpc_channel_stack_type type) {
       return "CLIENT_DIRECT_CHANNEL";
     case GRPC_CLIENT_DYNAMIC:
       return "CLIENT_DYNAMIC_CHANNEL";
+    case GRPC_CLIENT_VIRTUAL_CHANNEL:
+      return "CLIENT_VIRTUAL_CHANNEL";
+    case GRPC_SERVER_VIRTUAL_CHANNEL:
+      return "SERVER_VIRTUAL_CHANNEL";
     case GRPC_NUM_CHANNEL_STACK_TYPES:
       break;
   }

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

@@ -36,6 +36,10 @@ typedef enum {
   GRPC_CLIENT_DIRECT_CHANNEL,
   // server side channel
   GRPC_SERVER_CHANNEL,
+  // virtual client channel
+  GRPC_CLIENT_VIRTUAL_CHANNEL,
+  // virtual server channel
+  GRPC_SERVER_VIRTUAL_CHANNEL,
   // must be last
   GRPC_NUM_CHANNEL_STACK_TYPES
 } grpc_channel_stack_type;

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

@@ -331,7 +331,7 @@ struct cq_next_data {
   std::atomic<intptr_t> pending_events{1};
 
   /// 0 initially. 1 once we initiated shutdown
-  bool shutdown_called = false;
+  std::atomic<bool> shutdown_called{false};
 };
 
 struct cq_pluck_data {
@@ -369,7 +369,7 @@ struct cq_pluck_data {
   std::atomic<bool> shutdown{false};
 
   /// 0 initially. 1 once we initiated shutdown
-  bool shutdown_called = false;
+  std::atomic<bool> shutdown_called{false};
 
   int num_pluckers = 0;
   plucker pluckers[GRPC_MAX_COMPLETION_QUEUE_PLUCKERS];
@@ -396,7 +396,7 @@ struct cq_callback_data {
   std::atomic<intptr_t> pending_events{1};
 
   /// 0 initially. 1 once we initiated shutdown
-  bool shutdown_called = false;
+  std::atomic<bool> shutdown_called{false};
 
   /// A callback that gets invoked when the CQ completes shutdown
   grpc_completion_queue_functor* shutdown_callback;
@@ -1122,7 +1122,7 @@ static grpc_event cq_next(grpc_completion_queue* cq, gpr_timespec deadline,
 static void cq_finish_shutdown_next(grpc_completion_queue* cq) {
   cq_next_data* cqd = static_cast<cq_next_data*> DATA_FROM_CQ(cq);
 
-  GRPC_CHECK(cqd->shutdown_called);
+  GRPC_CHECK(cqd->shutdown_called.load(std::memory_order_acquire));
   GRPC_CHECK_EQ(cqd->pending_events.load(std::memory_order_relaxed), 0);
 
   cq->poller_vtable->shutdown(POLLSET_FROM_CQ(cq), &cq->pollset_shutdown_done);
@@ -1139,12 +1139,15 @@ static void cq_shutdown_next(grpc_completion_queue* cq) {
   // this function is still active
   GRPC_CQ_INTERNAL_REF(cq, "shutting_down");
   gpr_mu_lock(cq->mu);
-  if (cqd->shutdown_called) {
+  if (cqd->shutdown_called.load(std::memory_order_relaxed)) {
     gpr_mu_unlock(cq->mu);
     GRPC_CQ_INTERNAL_UNREF(cq, "shutting_down");
     return;
   }
-  cqd->shutdown_called = true;
+  // Using memory_order_release to ensure shutdown_called is visible to all
+  // threads on weak memory models like ARM64. This synchronizes-with the
+  // acquire load in cq_finish_shutdown_next and cq_end_op_for_next.
+  cqd->shutdown_called.store(true, std::memory_order_release);
   // Doing acq/release fetch_sub here to match with
   // cq_begin_op_for_next and cq_end_op_for_next functions which read/write
   // on this counter without necessarily holding a lock on cq
@@ -1347,7 +1350,7 @@ grpc_event grpc_completion_queue_pluck(grpc_completion_queue* cq, void* tag,
 static void cq_finish_shutdown_pluck(grpc_completion_queue* cq) {
   cq_pluck_data* cqd = static_cast<cq_pluck_data*> DATA_FROM_CQ(cq);
 
-  GRPC_CHECK(cqd->shutdown_called);
+  GRPC_CHECK(cqd->shutdown_called.load(std::memory_order_acquire));
   GRPC_CHECK(!cqd->shutdown.load(std::memory_order_relaxed));
   cqd->shutdown.store(true, std::memory_order_relaxed);
 
@@ -1367,12 +1370,12 @@ static void cq_shutdown_pluck(grpc_completion_queue* cq) {
   // this function is still active
   GRPC_CQ_INTERNAL_REF(cq, "shutting_down (pluck cq)");
   gpr_mu_lock(cq->mu);
-  if (cqd->shutdown_called) {
+  if (cqd->shutdown_called.load(std::memory_order_relaxed)) {
     gpr_mu_unlock(cq->mu);
     GRPC_CQ_INTERNAL_UNREF(cq, "shutting_down (pluck cq)");
     return;
   }
-  cqd->shutdown_called = true;
+  cqd->shutdown_called.store(true, std::memory_order_release);
   if (cqd->pending_events.fetch_sub(1, std::memory_order_acq_rel) == 1) {
     cq_finish_shutdown_pluck(cq);
   }
@@ -1384,7 +1387,7 @@ static void cq_finish_shutdown_callback(grpc_completion_queue* cq) {
   cq_callback_data* cqd = static_cast<cq_callback_data*> DATA_FROM_CQ(cq);
   auto* callback = cqd->shutdown_callback;
 
-  GRPC_CHECK(cqd->shutdown_called);
+  GRPC_CHECK(cqd->shutdown_called.load(std::memory_order_acquire));
 
   cq->poller_vtable->shutdown(POLLSET_FROM_CQ(cq), &cq->pollset_shutdown_done);
 
@@ -1405,12 +1408,12 @@ static void cq_shutdown_callback(grpc_completion_queue* cq) {
   // this function is still active
   GRPC_CQ_INTERNAL_REF(cq, "shutting_down (callback cq)");
   gpr_mu_lock(cq->mu);
-  if (cqd->shutdown_called) {
+  if (cqd->shutdown_called.load(std::memory_order_relaxed)) {
     gpr_mu_unlock(cq->mu);
     GRPC_CQ_INTERNAL_UNREF(cq, "shutting_down (callback cq)");
     return;
   }
-  cqd->shutdown_called = true;
+  cqd->shutdown_called.store(true, std::memory_order_release);
   if (cqd->pending_events.fetch_sub(1, std::memory_order_acq_rel) == 1) {
     gpr_mu_unlock(cq->mu);
     cq_finish_shutdown_callback(cq);

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

@@ -46,6 +46,7 @@
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/surface/call.h"
+#include "src/core/lib/surface/call_utils.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/completion_queue.h"
 #include "src/core/lib/transport/transport.h"
@@ -99,6 +100,10 @@ class FilterStackCall final : public Call {
   void SetCompletionQueue(grpc_completion_queue* cq) 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,
+                            grpc_error_handle error) override {
+    EndOpImmediately(cq_, notify_tag, is_notify_tag_closure, std::move(error));
+  }
   void ExternalRef() override { ext_ref_.Ref(); }
   void ExternalUnref() override;
   void InternalRef(const char* reason) override {

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

@@ -63,7 +63,7 @@ namespace grpc_core {
 
 absl::StatusOr<RefCountedPtr<Channel>> LegacyChannel::Create(
     std::string target, ChannelArgs args,
-    grpc_channel_stack_type channel_stack_type, const Blackboard* blackboard) {
+    grpc_channel_stack_type channel_stack_type) {
   if (grpc_channel_stack_type_is_client(channel_stack_type)) {
     auto channel_args_mutator =
         grpc_channel_args_get_client_channel_creation_mutator();
@@ -76,16 +76,6 @@ absl::StatusOr<RefCountedPtr<Channel>> LegacyChannel::Create(
   if (channel_stack_type == GRPC_SERVER_CHANNEL) {
     stats_plugin_group =
         GlobalStatsPluginRegistry::GetStatsPluginsForServer(args);
-    // Add per-server stats plugins.
-    auto* stats_plugin_list = args.GetPointer<
-        std::shared_ptr<std::vector<std::shared_ptr<StatsPlugin>>>>(
-        GRPC_ARG_EXPERIMENTAL_STATS_PLUGINS);
-    if (stats_plugin_list != nullptr) {
-      for (const auto& plugin : **stats_plugin_list) {
-        stats_plugin_group->AddStatsPlugin(plugin,
-                                           plugin->GetServerScopeConfig(args));
-      }
-    }
   } else {
     std::string authority = args.GetOwnedString(GRPC_ARG_DEFAULT_AUTHORITY)
                                 .value_or(CoreConfiguration::Get()
@@ -97,23 +87,12 @@ absl::StatusOr<RefCountedPtr<Channel>> LegacyChannel::Create(
                                                 endpoint_config);
     stats_plugin_group =
         GlobalStatsPluginRegistry::GetStatsPluginsForChannel(scope);
-    // Add per-channel stats plugins.
-    auto* stats_plugin_list = args.GetPointer<
-        std::shared_ptr<std::vector<std::shared_ptr<StatsPlugin>>>>(
-        GRPC_ARG_EXPERIMENTAL_STATS_PLUGINS);
-    if (stats_plugin_list != nullptr) {
-      for (const auto& plugin : **stats_plugin_list) {
-        stats_plugin_group->AddStatsPlugin(
-            plugin, plugin->GetChannelScopeConfig(scope));
-      }
-    }
   }
   args = args.SetObject(stats_plugin_group);
   ChannelStackBuilderImpl builder(
       grpc_channel_stack_type_string(channel_stack_type), channel_stack_type,
       args);
   builder.SetTarget(target.c_str());
-  builder.SetBlackboard(blackboard);
   if (!CoreConfiguration::Get().channel_init().CreateStack(&builder)) {
     return nullptr;
   }

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

@@ -28,7 +28,6 @@
 
 #include "src/core/call/call_arena_allocator.h"
 #include "src/core/client_channel/client_channel_filter.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"  // IWYU pragma: keep
@@ -48,8 +47,7 @@ class LegacyChannel final : public Channel {
  public:
   static absl::StatusOr<RefCountedPtr<Channel>> Create(
       std::string target, ChannelArgs args,
-      grpc_channel_stack_type channel_stack_type,
-      const Blackboard* blackboard = nullptr);
+      grpc_channel_stack_type channel_stack_type);
 
   // Do not instantiate directly -- use Create() instead.
   LegacyChannel(bool is_client, std::string target,

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

@@ -22,6 +22,6 @@
 #include <grpc/grpc.h>
 #include <grpc/support/port_platform.h>
 
-const char* grpc_version_string(void) { return "53.0.0"; }
+const char* grpc_version_string(void) { return "54.0.0"; }
 
-const char* grpc_g_stands_for(void) { return "glimmering"; }
+const char* grpc_g_stands_for(void) { return "graphic"; }

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

@@ -25,7 +25,9 @@
 #include <algorithm>
 
 #include "src/core/util/grpc_check.h"
+#include "src/core/util/shared_bit_gen.h"
 #include "absl/log/log.h"
+#include "absl/random/random.h"
 
 namespace grpc_core {
 
@@ -61,9 +63,10 @@ Timestamp BdpEstimator::CompletePing() {
   } else if (inter_ping_delay_ < Duration::Seconds(10)) {
     stable_estimate_count_++;
     if (stable_estimate_count_ >= 2) {
-      // if the ping estimate is steady, slowly ramp down the probe time
-      inter_ping_delay_ += Duration::Milliseconds(
-          100 + static_cast<int>(rand() * 100.0 / RAND_MAX));
+      // If the ping estimate is steady, slowly ramp down the probe time.
+      // Random jitter avoids synchronized cross-connection thundering herds.
+      inter_ping_delay_ +=
+          Duration::Milliseconds(absl::Uniform<int>(SharedBitGen(), 100, 200));
     }
   }
   if (start_inter_ping_delay != inter_ping_delay_) {

data/src/core/lib/transport/promise_endpoint.h

@@ -25,9 +25,7 @@
 
 #include <atomic>
 #include <cstring>
-#include <functional>
 #include <memory>
-#include <optional>
 #include <utility>
 
 #include "src/core/lib/event_engine/extensions/chaotic_good_extension.h"
@@ -40,10 +38,7 @@
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_buffer.h"
-#include "src/core/util/dump_args.h"
 #include "src/core/util/grpc_check.h"
-#include "src/core/util/sync.h"
-#include "absl/base/thread_annotations.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 
@@ -73,7 +68,7 @@ class PromiseEndpoint {
   // Concurrent writes are not supported, which means callers should not call
   // `Write()` before the previous write finishes. Doing that results in
   // undefined behavior.
-  auto Write(SliceBuffer data, WriteArgs write_args) {
+  auto Write(SliceBuffer&& data, WriteArgs write_args) {
     GRPC_LATENT_SEE_SCOPE("GRPC:Write");
     // Start write and assert previous write finishes.
     auto prev = write_state_->state.exchange(WriteState::kWriting,
@@ -170,12 +165,12 @@ class PromiseEndpoint {
     return If(
         complete,
         [this, num_bytes]() {
-          SliceBuffer ret;
-          grpc_slice_buffer_move_first_no_inline(
-              read_state_->buffer.c_slice_buffer(), num_bytes,
-              ret.c_slice_buffer());
-          return [ret = std::move(
-                      ret)]() mutable -> Poll<absl::StatusOr<SliceBuffer>> {
+          return [read_state = read_state_,
+                  num_bytes]() mutable -> Poll<absl::StatusOr<SliceBuffer>> {
+            SliceBuffer ret;
+            grpc_slice_buffer_move_first_no_inline(
+                read_state->buffer.c_slice_buffer(), num_bytes,
+                ret.c_slice_buffer());
             return std::move(ret);
           };
         },
@@ -209,11 +204,12 @@ class PromiseEndpoint {
   // `ReadSlice()` before the previous read finishes. Doing that results in
   // undefined behavior.
   auto ReadSlice(size_t num_bytes) {
-    return Map(Read(num_bytes),
-               [](absl::StatusOr<SliceBuffer> buffer) -> absl::StatusOr<Slice> {
-                 if (!buffer.ok()) return buffer.status();
-                 return buffer->JoinIntoSlice();
-               });
+    return Map(
+        Read(num_bytes),
+        [](absl::StatusOr<SliceBuffer>&& buffer) -> absl::StatusOr<Slice> {
+          if (!buffer.ok()) return buffer.status();
+          return buffer->JoinIntoSlice();
+        });
   }
 
   // Returns a promise that resolves to a byte with type `uint8_t`.

data/src/core/load_balancing/endpoint_list.cc

@@ -28,7 +28,6 @@
 
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/load_balancing/delegating_helper.h"
 #include "src/core/load_balancing/lb_policy.h"
@@ -171,13 +170,6 @@ void EndpointList::Init(
                                               const ChannelArgs&)>
         create_endpoint) {
   if (endpoints == nullptr) return;
-  if (!IsRrWrrConnectFromRandomIndexEnabled()) {
-    endpoints->ForEach([&](const EndpointAddresses& endpoint) {
-      endpoints_.push_back(
-          create_endpoint(Ref(DEBUG_LOCATION, "Endpoint"), endpoint, args));
-    });
-    return;
-  }
   // If all clients get the same endpoint list in the same order, and they
   // all start connection attempts in that order, and all connection attempts
   // take approximately the same amount of time, then all clients are

data/src/core/load_balancing/pick_first/pick_first.cc

@@ -615,12 +615,6 @@ void PickFirst::GoIdle() {
   UnsetSelectedSubchannel();
   // Drop the current subchannel list, if any.
   subchannel_list_.reset();
-  if (!IsPickFirstReadyToConnectingEnabled()) {
-    // Request a re-resolution.
-    // TODO(roth): We may want to request re-resolution in
-    // ExitIdleLocked() instead.
-    channel_control_helper()->RequestReresolution();
-  }
   // Enter idle.
   UpdateState(GRPC_CHANNEL_IDLE, absl::OkStatus(),
               MakeRefCounted<QueuePicker>(Ref(DEBUG_LOCATION, "QueuePicker")));
@@ -785,17 +779,14 @@ void PickFirst::SubchannelList::SubchannelData::SubchannelState::
   stats_plugins.AddCounter(kMetricDisconnections, 1,
                            {pick_first_->channel_control_helper()->GetTarget()},
                            {});
-  if (IsPickFirstReadyToConnectingEnabled()) {
-    // TODO(roth): We may want to request re-resolution in
-    // ExitIdleLocked() instead, at least if we go IDLE below.
-    pick_first_->channel_control_helper()->RequestReresolution();
-  }
+  // TODO(roth): We may want to request re-resolution in
+  // ExitIdleLocked() instead, at least if we go IDLE below.
+  pick_first_->channel_control_helper()->RequestReresolution();
   // If the subchannel went to CONNECTING or TRANSIENT_FAILURE, we go
   // back to CONNECTING and start a new Happy Eyeballs pass.
   // Otherwise, go IDLE.
-  if (IsPickFirstReadyToConnectingEnabled() &&
-      (new_state == GRPC_CHANNEL_CONNECTING ||
-       new_state == GRPC_CHANNEL_TRANSIENT_FAILURE)) {
+  if (new_state == GRPC_CHANNEL_CONNECTING ||
+      new_state == GRPC_CHANNEL_TRANSIENT_FAILURE) {
     pick_first_->UpdateState(GRPC_CHANNEL_CONNECTING, absl::OkStatus(),
                              MakeRefCounted<QueuePicker>(nullptr));
     pick_first_->AttemptToConnectUsingLatestUpdateArgsLocked();