grpc 1.63.0 → 1.65.2

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

@@ -19,13 +19,12 @@
 #ifndef GRPC_SRC_CORE_LIB_SURFACE_CALL_H
 #define GRPC_SRC_CORE_LIB_SURFACE_CALL_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stddef.h>
 #include <stdint.h>
 
 #include "absl/functional/any_invocable.h"
 #include "absl/functional/function_ref.h"
+#include "absl/log/check.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
@@ -33,12 +32,11 @@
 #include <grpc/impl/compression_types.h>
 #include <grpc/support/atm.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
-#include "src/core/lib/channel/context.h"
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gpr/time_precise.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/closure.h"
@@ -50,8 +48,9 @@
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/channel.h"
-#include "src/core/lib/surface/server_interface.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/server/server_interface.h"
+#include "src/core/util/time_precise.h"
 
 typedef void (*grpc_ioreq_completion_func)(grpc_call* call, int success,
                                            void* user_data);
@@ -77,91 +76,172 @@ typedef struct grpc_call_create_args {
 } grpc_call_create_args;
 
 namespace grpc_core {
-class BasicPromiseBasedCall;
-class ServerPromiseBasedCall;
-
-class ServerCallContext {
- public:
-  virtual void PublishInitialMetadata(
-      ClientMetadataHandle metadata,
-      grpc_metadata_array* publish_initial_metadata) = 0;
-
-  // Construct the top of the server call promise for the v2 filter stack.
-  // TODO(ctiller): delete when v3 is available.
-  virtual ArenaPromise<ServerMetadataHandle> MakeTopOfServerCallPromise(
-      CallArgs call_args, grpc_completion_queue* cq,
-      absl::FunctionRef<void(grpc_call* call)> publish) = 0;
-
-  // Server stream data as supplied by the transport (so we can link the
-  // transport stream up with the call again).
-  // TODO(ctiller): legacy API - once we move transports to promises we'll
-  // create the promise directly and not need to pass around this token.
-  virtual const void* server_stream_data() = 0;
 
- protected:
-  ~ServerCallContext() = default;
+template <>
+struct ArenaContextType<census_context> {
+  static void Destroy(census_context*) {}
 };
 
-// TODO(ctiller): move more call things into this type
-class CallContext {
+class Call : public CppImplOf<Call, grpc_call>,
+             public grpc_event_engine::experimental::EventEngine::
+                 Closure /* for deadlines */ {
  public:
-  explicit CallContext(BasicPromiseBasedCall* call) : call_(call) {}
-
-  // Update the deadline (if deadline < the current deadline).
-  void UpdateDeadline(Timestamp deadline);
-  Timestamp deadline() const;
-
-  // Run some action in the call activity context. This is needed to adapt some
-  // legacy systems to promises, and will likely disappear once that conversion
-  // is complete.
-  void RunInContext(absl::AnyInvocable<void()> fn);
+  Arena* arena() { return arena_.get(); }
+  bool is_client() const { return is_client_; }
+
+  virtual bool Completed() = 0;
+  void CancelWithStatus(grpc_status_code status, const char* description);
+  virtual void CancelWithError(grpc_error_handle error) = 0;
+  virtual void SetCompletionQueue(grpc_completion_queue* cq) = 0;
+  virtual char* GetPeer() = 0;
+  virtual grpc_call_error StartBatch(const grpc_op* ops, size_t nops,
+                                     void* notify_tag,
+                                     bool is_notify_tag_closure) = 0;
+  virtual bool failed_before_recv_message() const = 0;
+  virtual bool is_trailers_only() const = 0;
+  virtual absl::string_view GetServerAuthority() const = 0;
+  virtual void ExternalRef() = 0;
+  virtual void ExternalUnref() = 0;
+  virtual void InternalRef(const char* reason) = 0;
+  virtual void InternalUnref(const char* reason) = 0;
+
+  void UpdateDeadline(Timestamp deadline) ABSL_LOCKS_EXCLUDED(deadline_mu_);
+  void ResetDeadline() ABSL_LOCKS_EXCLUDED(deadline_mu_);
+  Timestamp deadline() {
+    MutexLock lock(&deadline_mu_);
+    return deadline_;
+  }
 
-  // TODO(ctiller): remove this once transport APIs are promise based
-  void IncrementRefCount(const char* reason = "call_context");
+  virtual uint32_t test_only_message_flags() = 0;
+  CompressionAlgorithmSet encodings_accepted_by_peer() {
+    return encodings_accepted_by_peer_;
+  }
 
-  // TODO(ctiller): remove this once transport APIs are promise based
-  void Unref(const char* reason = "call_context");
+  // This should return nullptr for the promise stack (and alternative means
+  // for that functionality be invented)
+  virtual grpc_call_stack* call_stack() = 0;
 
-  RefCountedPtr<CallContext> Ref() {
-    IncrementRefCount();
-    return RefCountedPtr<CallContext>(this);
+  // Return the EventEngine used for this call's async execution.
+  grpc_event_engine::experimental::EventEngine* event_engine() const {
+    return event_engine_;
   }
 
-  grpc_call_stats* call_stats() { return &call_stats_; }
-  gpr_atm* peer_string_atm_ptr();
-  gpr_cycle_counter call_start_time() { return start_time_; }
+  // Implementation of EventEngine::Closure, called when deadline expires
+  void Run() final;
 
-  ServerCallContext* server_call_context();
+  gpr_cycle_counter start_time() const { return start_time_; }
 
   void set_traced(bool traced) { traced_ = traced; }
   bool traced() const { return traced_; }
 
-  // TEMPORARY HACK
-  // Create a call spine object for this call.
-  // Said object should only be created once.
-  // Allows interop between the v2 call stack and the v3 (which is required by
-  // transports).
-  RefCountedPtr<CallSpineInterface> MakeCallSpine(CallArgs call_args);
-  grpc_call* c_call();
+  virtual grpc_compression_algorithm incoming_compression_algorithm() = 0;
+
+ protected:
+  // The maximum number of concurrent batches possible.
+  // Based upon the maximum number of individually queueable ops in the batch
+  // api:
+  //    - initial metadata send
+  //    - message send
+  //    - status/close send (depending on client/server)
+  //    - initial metadata recv
+  //    - message recv
+  //    - status/close recv (depending on client/server)
+  static constexpr size_t kMaxConcurrentBatches = 6;
+
+  struct ParentCall {
+    Mutex child_list_mu;
+    Call* first_child ABSL_GUARDED_BY(child_list_mu) = nullptr;
+  };
+
+  struct ChildCall {
+    explicit ChildCall(Call* parent) : parent(parent) {}
+    Call* parent;
+    /// siblings: children of the same parent form a list, and this list is
+    /// protected under
+    /// parent->mu
+    Call* sibling_next = nullptr;
+    Call* sibling_prev = nullptr;
+  };
+
+  Call(bool is_client, Timestamp send_deadline, RefCountedPtr<Arena> arena,
+       grpc_event_engine::experimental::EventEngine* event_engine);
+  ~Call() override = default;
+
+  ParentCall* GetOrCreateParentCall();
+  ParentCall* parent_call();
+
+  absl::Status InitParent(Call* parent, uint32_t propagation_mask);
+  void PublishToParent(Call* parent);
+  void MaybeUnpublishFromParent();
+  void PropagateCancellationToChildren();
+
+  Timestamp send_deadline() const { return send_deadline_; }
+  void set_send_deadline(Timestamp send_deadline) {
+    send_deadline_ = send_deadline;
+  }
+
+  Slice GetPeerString() const {
+    MutexLock lock(&peer_mu_);
+    return peer_string_.Ref();
+  }
+
+  void SetPeerString(Slice peer_string) {
+    MutexLock lock(&peer_mu_);
+    peer_string_ = std::move(peer_string);
+  }
+
+  void ClearPeerString() { SetPeerString(Slice(grpc_empty_slice())); }
+
+  // TODO(ctiller): cancel_func is for cancellation of the call - filter stack
+  // holds no mutexes here, promise stack does, and so locking is different.
+  // Remove this and cancel directly once promise conversion is done.
+  void ProcessIncomingInitialMetadata(grpc_metadata_batch& md);
+  // Fixup outgoing metadata before sending - adds compression, protects
+  // internal headers against external modification.
+  void PrepareOutgoingInitialMetadata(const grpc_op& op,
+                                      grpc_metadata_batch& md);
+
+  void HandleCompressionAlgorithmDisabled(
+      grpc_compression_algorithm compression_algorithm) GPR_ATTRIBUTE_NOINLINE;
+  void HandleCompressionAlgorithmNotAccepted(
+      grpc_compression_algorithm compression_algorithm) GPR_ATTRIBUTE_NOINLINE;
+
+  virtual grpc_compression_options compression_options() = 0;
+
+  virtual void SetIncomingCompressionAlgorithm(
+      grpc_compression_algorithm algorithm) = 0;
 
  private:
-  friend class PromiseBasedCall;
-  // Call final info.
-  grpc_call_stats call_stats_;
-  // TODO(ctiller): remove this once transport APIs are promise based and we
-  // don't need refcounting here.
-  BasicPromiseBasedCall* const call_;
-  gpr_cycle_counter start_time_ = gpr_get_cycle_counter();
+  const RefCountedPtr<Arena> arena_;
+  std::atomic<ParentCall*> parent_call_{nullptr};
+  ChildCall* child_ = nullptr;
+  Timestamp send_deadline_;
+  const bool is_client_;
+  // flag indicating that cancellation is inherited
+  bool cancellation_is_inherited_ = false;
   // Is this call traced?
   bool traced_ = false;
+  // Supported encodings (compression algorithms), a bitset.
+  // Always support no compression.
+  CompressionAlgorithmSet encodings_accepted_by_peer_{GRPC_COMPRESS_NONE};
+  // Peer name is protected by a mutex because it can be accessed by the
+  // application at the same moment as it is being set by the completion
+  // of the recv_initial_metadata op.  The mutex should be mostly uncontended.
+  mutable Mutex peer_mu_;
+  Slice peer_string_;
+  // Current deadline.
+  Mutex deadline_mu_;
+  Timestamp deadline_ ABSL_GUARDED_BY(deadline_mu_) = Timestamp::InfFuture();
+  grpc_event_engine::experimental::EventEngine::TaskHandle ABSL_GUARDED_BY(
+      deadline_mu_) deadline_task_;
+  grpc_event_engine::experimental::EventEngine* const event_engine_;
+  gpr_cycle_counter start_time_ = gpr_get_cycle_counter();
 };
 
 template <>
-struct ContextType<CallContext> {};
-
-RefCountedPtr<CallSpineInterface> MakeServerCall(ServerInterface* server,
-                                                 Channel* channel,
-                                                 Arena* arena);
+struct ArenaContextType<Call> {
+  static void Destroy(Call*) {}
+};
 
 }  // namespace grpc_core
 
@@ -192,28 +272,19 @@ grpc_call* grpc_call_from_top_element(grpc_call_element* surface_element);
 void grpc_call_log_batch(const char* file, int line, gpr_log_severity severity,
                          const grpc_op* ops, size_t nops);
 
-// Set a context pointer.
-// No thread safety guarantees are made wrt this value.
-// TODO(#9731): add exec_ctx to destroy
-void grpc_call_context_set(grpc_call* call, grpc_context_index elem,
-                           void* value, void (*destroy)(void* value));
-// Get a context pointer.
-void* grpc_call_context_get(grpc_call* call, grpc_context_index elem);
-
-#define GRPC_CALL_LOG_BATCH(sev, ops, nops)        \
-  do {                                             \
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_api_trace)) { \
-      grpc_call_log_batch(sev, ops, nops);         \
-    }                                              \
+void grpc_call_tracer_set(grpc_call* call, grpc_core::ClientCallTracer* tracer);
+
+void* grpc_call_tracer_get(grpc_call* call);
+
+#define GRPC_CALL_LOG_BATCH(sev, ops, nops) \
+  do {                                      \
+    if (GRPC_TRACE_FLAG_ENABLED(api)) {     \
+      grpc_call_log_batch(sev, ops, nops);  \
+    }                                       \
   } while (0)
 
 uint8_t grpc_call_is_client(grpc_call* call);
 
-// Get the estimated memory size for a call BESIDES the call stack. Combined
-// with the size of the call stack, it helps estimate the arena size for the
-// initial call.
-size_t grpc_call_get_initial_size_estimate();
-
 // Return an appropriate compression algorithm for the requested compression \a
 // level in the context of \a call.
 grpc_compression_algorithm grpc_call_compression_for_level(
@@ -227,7 +298,4 @@ bool grpc_call_is_trailers_only(const grpc_call* call);
 // Returns the authority for the call, as seen on the server side.
 absl::string_view grpc_call_server_authority(const grpc_call* call);
 
-extern grpc_core::TraceFlag grpc_call_error_trace;
-extern grpc_core::TraceFlag grpc_compression_trace;
-
 #endif  // GRPC_SRC_CORE_LIB_SURFACE_CALL_H

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

@@ -16,10 +16,9 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include <grpc/grpc.h>
 #include <grpc/slice.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/exec_ctx.h"

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

@@ -16,8 +16,6 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include <inttypes.h>
 #include <stddef.h>
 
@@ -31,11 +29,12 @@
 #include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
 #include "src/core/lib/surface/call.h"
+#include "src/core/util/string.h"
 
 static void add_metadata(const grpc_metadata* md, size_t count,
                          std::vector<std::string>* b) {

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

@@ -19,12 +19,11 @@
 #ifndef GRPC_SRC_CORE_LIB_SURFACE_CALL_TEST_ONLY_H
 #define GRPC_SRC_CORE_LIB_SURFACE_CALL_TEST_ONLY_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stdint.h>
 
 #include <grpc/grpc.h>
 #include <grpc/impl/compression_types.h>
+#include <grpc/support/port_platform.h>
 
 /// Return the message compression algorithm from \a call.
 ///

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

@@ -0,0 +1,276 @@
+// Copyright 2024 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/lib/surface/call_utils.h"
+
+#include <inttypes.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <algorithm>
+#include <atomic>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include "absl/log/check.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
+#include "absl/strings/string_view.h"
+
+#include <grpc/byte_buffer.h>
+#include <grpc/compression.h>
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/grpc.h>
+#include <grpc/impl/call.h>
+#include <grpc/impl/propagation_bits.h>
+#include <grpc/slice.h>
+#include <grpc/slice_buffer.h>
+#include <grpc/status.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/atm.h>
+#include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
+#include <grpc/support/string_util.h>
+
+#include "src/core/lib/channel/status_util.h"
+#include "src/core/lib/gprpp/crash.h"
+#include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/match.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/promise/activity.h"
+#include "src/core/lib/promise/context.h"
+#include "src/core/lib/promise/poll.h"
+#include "src/core/lib/promise/status_flag.h"
+#include "src/core/lib/slice/slice_buffer.h"
+#include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/surface/completion_queue.h"
+#include "src/core/lib/surface/validate_metadata.h"
+#include "src/core/lib/transport/metadata.h"
+#include "src/core/lib/transport/metadata_batch.h"
+
+namespace grpc_core {
+
+void PublishMetadataArray(grpc_metadata_batch* md, grpc_metadata_array* array,
+                          bool is_client) {
+  const auto md_count = md->count();
+  if (md_count > array->capacity) {
+    array->capacity =
+        std::max(array->capacity + md->count(), array->capacity * 3 / 2);
+    array->metadata = static_cast<grpc_metadata*>(
+        gpr_realloc(array->metadata, sizeof(grpc_metadata) * array->capacity));
+  }
+  PublishToAppEncoder encoder(array, md, is_client);
+  md->Encode(&encoder);
+}
+
+void CToMetadata(grpc_metadata* metadata, size_t count,
+                 grpc_metadata_batch* b) {
+  for (size_t i = 0; i < count; i++) {
+    grpc_metadata* md = &metadata[i];
+    auto key = StringViewFromSlice(md->key);
+    // Filter "content-length metadata"
+    if (key == "content-length") continue;
+    b->Append(key, Slice(CSliceRef(md->value)),
+              [md](absl::string_view error, const Slice& value) {
+                gpr_log(GPR_DEBUG, "Append error: %s",
+                        absl::StrCat("key=", StringViewFromSlice(md->key),
+                                     " error=", error,
+                                     " value=", value.as_string_view())
+                            .c_str());
+              });
+  }
+}
+
+const char* GrpcOpTypeName(grpc_op_type op) {
+  switch (op) {
+    case GRPC_OP_SEND_INITIAL_METADATA:
+      return "SendInitialMetadata";
+    case GRPC_OP_SEND_MESSAGE:
+      return "SendMessage";
+    case GRPC_OP_SEND_STATUS_FROM_SERVER:
+      return "SendStatusFromServer";
+    case GRPC_OP_SEND_CLOSE_FROM_CLIENT:
+      return "SendCloseFromClient";
+    case GRPC_OP_RECV_MESSAGE:
+      return "RecvMessage";
+    case GRPC_OP_RECV_CLOSE_ON_SERVER:
+      return "RecvCloseOnServer";
+    case GRPC_OP_RECV_INITIAL_METADATA:
+      return "RecvInitialMetadata";
+    case GRPC_OP_RECV_STATUS_ON_CLIENT:
+      return "RecvStatusOnClient";
+  }
+  Crash("Unreachable");
+}
+
+////////////////////////////////////////////////////////////////////////
+// WaitForCqEndOp
+
+Poll<Empty> WaitForCqEndOp::operator()() {
+  GRPC_TRACE_LOG(promise_primitives, INFO)
+      << Activity::current()->DebugTag() << "WaitForCqEndOp[" << this << "] "
+      << StateString(state_);
+  if (auto* n = absl::get_if<NotStarted>(&state_)) {
+    if (n->is_closure) {
+      ExecCtx::Run(DEBUG_LOCATION, static_cast<grpc_closure*>(n->tag),
+                   std::move(n->error));
+      return Empty{};
+    } else {
+      auto not_started = std::move(*n);
+      auto& started =
+          state_.emplace<Started>(GetContext<Activity>()->MakeOwningWaker());
+      grpc_cq_end_op(
+          not_started.cq, not_started.tag, std::move(not_started.error),
+          [](void* p, grpc_cq_completion*) {
+            auto started = static_cast<Started*>(p);
+            auto wakeup = std::move(started->waker);
+            started->done.store(true, std::memory_order_release);
+            wakeup.Wakeup();
+          },
+          &started, &started.completion);
+    }
+  }
+  auto& started = absl::get<Started>(state_);
+  if (started.done.load(std::memory_order_acquire)) {
+    return Empty{};
+  } else {
+    return Pending{};
+  }
+}
+
+std::string WaitForCqEndOp::StateString(const State& state) {
+  return Match(
+      state,
+      [](const NotStarted& x) {
+        return absl::StrFormat(
+            "NotStarted{is_closure=%s, tag=%p, error=%s, cq=%p}",
+            x.is_closure ? "true" : "false", x.tag, x.error.ToString(), x.cq);
+      },
+      [](const Started& x) {
+        return absl::StrFormat(
+            "Started{completion=%p, done=%s}", &x.completion,
+            x.done.load(std::memory_order_relaxed) ? "true" : "false");
+      },
+      [](const Invalid&) -> std::string { return "Invalid{}"; });
+}
+
+////////////////////////////////////////////////////////////////////////
+// MessageReceiver
+
+StatusFlag MessageReceiver::FinishRecvMessage(
+    ValueOrFailure<absl::optional<MessageHandle>> result) {
+  if (!result.ok()) {
+    GRPC_TRACE_LOG(call, INFO) << Activity::current()->DebugTag()
+                               << "[call] RecvMessage: outstanding_recv "
+                                  "finishes: received end-of-stream with error";
+    *recv_message_ = nullptr;
+    recv_message_ = nullptr;
+    return Failure{};
+  }
+  if (!result->has_value()) {
+    GRPC_TRACE_LOG(call, INFO) << Activity::current()->DebugTag()
+                               << "[call] RecvMessage: outstanding_recv "
+                                  "finishes: received end-of-stream";
+    *recv_message_ = nullptr;
+    recv_message_ = nullptr;
+    return Success{};
+  }
+  MessageHandle& message = **result;
+  test_only_last_message_flags_ = message->flags();
+  if ((message->flags() & GRPC_WRITE_INTERNAL_COMPRESS) &&
+      (incoming_compression_algorithm_ != GRPC_COMPRESS_NONE)) {
+    *recv_message_ = grpc_raw_compressed_byte_buffer_create(
+        nullptr, 0, incoming_compression_algorithm_);
+  } else {
+    *recv_message_ = grpc_raw_byte_buffer_create(nullptr, 0);
+  }
+  grpc_slice_buffer_move_into(message->payload()->c_slice_buffer(),
+                              &(*recv_message_)->data.raw.slice_buffer);
+  GRPC_TRACE_LOG(call, INFO)
+      << Activity::current()->DebugTag()
+      << "[call] RecvMessage: outstanding_recv "
+         "finishes: received "
+      << (*recv_message_)->data.raw.slice_buffer.length << " byte message";
+  recv_message_ = nullptr;
+  return Success{};
+}
+
+////////////////////////////////////////////////////////////////////////
+// MakeErrorString
+
+std::string MakeErrorString(const ServerMetadata* trailing_metadata) {
+  std::string out = absl::StrCat(
+      trailing_metadata->get(GrpcStatusFromWire()).value_or(false)
+          ? "Error received from peer"
+          : "Error generated by client",
+      "grpc_status: ",
+      grpc_status_code_to_string(trailing_metadata->get(GrpcStatusMetadata())
+                                     .value_or(GRPC_STATUS_UNKNOWN)));
+  if (const Slice* message =
+          trailing_metadata->get_pointer(GrpcMessageMetadata())) {
+    absl::StrAppend(&out, "\ngrpc_message: ", message->as_string_view());
+  }
+  if (auto annotations = trailing_metadata->get_pointer(GrpcStatusContext())) {
+    absl::StrAppend(&out, "\nStatus Context:");
+    for (const std::string& annotation : *annotations) {
+      absl::StrAppend(&out, "\n  ", annotation);
+    }
+  }
+  return out;
+}
+
+bool ValidateMetadata(size_t count, grpc_metadata* metadata) {
+  if (count > INT_MAX) {
+    return false;
+  }
+  for (size_t i = 0; i < count; i++) {
+    grpc_metadata* md = &metadata[i];
+    if (!GRPC_LOG_IF_ERROR("validate_metadata",
+                           grpc_validate_header_key_is_legal(md->key))) {
+      return false;
+    } else if (!grpc_is_binary_header_internal(md->key) &&
+               !GRPC_LOG_IF_ERROR(
+                   "validate_metadata",
+                   grpc_validate_header_nonbin_value_is_legal(md->value))) {
+      return false;
+    } else if (GRPC_SLICE_LENGTH(md->value) >= UINT32_MAX) {
+      // HTTP2 hpack encoding has a maximum limit.
+      return false;
+    }
+  }
+  return true;
+}
+
+void EndOpImmediately(grpc_completion_queue* cq, void* notify_tag,
+                      bool is_notify_tag_closure) {
+  if (!is_notify_tag_closure) {
+    CHECK(grpc_cq_begin_op(cq, notify_tag));
+    grpc_cq_end_op(
+        cq, notify_tag, absl::OkStatus(),
+        [](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());
+  }
+}
+
+}  // namespace grpc_core