grpc 1.46.3-x86_64-linux → 1.47.0-x86_64-linux

data/src/core/lib/address_utils/sockaddr_utils.cc

@@ -26,8 +26,10 @@
 
 #include <string>
 
+#include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
+#include "absl/strings/str_replace.h"
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -36,33 +38,41 @@
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/socket_utils.h"
+#include "src/core/lib/uri/uri_parser.h"
 
 #ifdef GRPC_HAVE_UNIX_SOCKET
 #include <sys/un.h>
 #endif
 
 #ifdef GRPC_HAVE_UNIX_SOCKET
-static std::string grpc_sockaddr_to_uri_unix_if_possible(
+static absl::StatusOr<std::string> grpc_sockaddr_to_uri_unix_if_possible(
     const grpc_resolved_address* resolved_addr) {
   const grpc_sockaddr* addr =
       reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
   if (addr->sa_family != AF_UNIX) {
-    return "";
+    return absl::InvalidArgumentError(
+        absl::StrCat("Socket family is not AF_UNIX: ", addr->sa_family));
   }
   const auto* unix_addr = reinterpret_cast<const struct sockaddr_un*>(addr);
+  std::string scheme, path;
   if (unix_addr->sun_path[0] == '\0' && unix_addr->sun_path[1] != '\0') {
-    return absl::StrCat(
-        "unix-abstract:",
-        absl::string_view(
-            unix_addr->sun_path + 1,
-            resolved_addr->len - sizeof(unix_addr->sun_family) - 1));
+    scheme = "unix-abstract";
+    path = std::string(unix_addr->sun_path + 1,
+                       resolved_addr->len - sizeof(unix_addr->sun_family) - 1);
+  } else {
+    scheme = "unix";
+    path = unix_addr->sun_path;
   }
-  return absl::StrCat("unix:", unix_addr->sun_path);
+  absl::StatusOr<grpc_core::URI> uri = grpc_core::URI::Create(
+      std::move(scheme), /*authority=*/"", std::move(path),
+      /*query_parameter_pairs=*/{}, /*fragment=*/"");
+  if (!uri.ok()) return uri.status();
+  return uri->ToString();
 }
 #else
-static std::string grpc_sockaddr_to_uri_unix_if_possible(
+static absl::StatusOr<std::string> grpc_sockaddr_to_uri_unix_if_possible(
     const grpc_resolved_address* /* addr */) {
-  return "";
+  return absl::InvalidArgumentError("Unix socket is not supported.");
 }
 #endif
 
@@ -182,8 +192,8 @@ void grpc_sockaddr_make_wildcard6(int port,
   resolved_wild_out->len = static_cast<socklen_t>(sizeof(grpc_sockaddr_in6));
 }
 
-std::string grpc_sockaddr_to_string(const grpc_resolved_address* resolved_addr,
-                                    bool normalize) {
+absl::StatusOr<std::string> grpc_sockaddr_to_string(
+    const grpc_resolved_address* resolved_addr, bool normalize) {
   const int save_errno = errno;
   grpc_resolved_address addr_normalized;
   if (normalize && grpc_sockaddr_is_v4mapped(resolved_addr, &addr_normalized)) {
@@ -191,6 +201,28 @@ std::string grpc_sockaddr_to_string(const grpc_resolved_address* resolved_addr,
   }
   const grpc_sockaddr* addr =
       reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
+  std::string out;
+#ifdef GRPC_HAVE_UNIX_SOCKET
+  if (addr->sa_family == GRPC_AF_UNIX) {
+    const sockaddr_un* addr_un = reinterpret_cast<const sockaddr_un*>(addr);
+    bool abstract = addr_un->sun_path[0] == '\0';
+    if (abstract) {
+      int len = resolved_addr->len - sizeof(addr->sa_family);
+      if (len <= 0) {
+        return absl::InvalidArgumentError("empty UDS abstract path");
+      }
+      out = std::string(addr_un->sun_path, len);
+    } else {
+      size_t maxlen = sizeof(addr_un->sun_path);
+      if (strnlen(addr_un->sun_path, maxlen) == maxlen) {
+        return absl::InvalidArgumentError("UDS path is not null-terminated");
+      }
+      out = std::string(addr_un->sun_path);
+    }
+    return out;
+  }
+#endif
+
   const void* ip = nullptr;
   int port = 0;
   uint32_t sin6_scope_id = 0;
@@ -207,7 +239,6 @@ std::string grpc_sockaddr_to_string(const grpc_resolved_address* resolved_addr,
     sin6_scope_id = addr6->sin6_scope_id;
   }
   char ntop_buf[GRPC_INET6_ADDRSTRLEN];
-  std::string out;
   if (ip != nullptr && grpc_inet_ntop(addr->sa_family, ip, ntop_buf,
                                       sizeof(ntop_buf)) != nullptr) {
     if (sin6_scope_id != 0) {
@@ -219,15 +250,19 @@ std::string grpc_sockaddr_to_string(const grpc_resolved_address* resolved_addr,
       out = grpc_core::JoinHostPort(ntop_buf, port);
     }
   } else {
-    out = absl::StrFormat("(sockaddr family=%d)", addr->sa_family);
+    return absl::InvalidArgumentError(
+        absl::StrCat("Unknown sockaddr family: ", addr->sa_family));
   }
   /* This is probably redundant, but we wouldn't want to log the wrong error. */
   errno = save_errno;
   return out;
 }
 
-std::string grpc_sockaddr_to_uri(const grpc_resolved_address* resolved_addr) {
-  if (resolved_addr->len == 0) return "";
+absl::StatusOr<std::string> grpc_sockaddr_to_uri(
+    const grpc_resolved_address* resolved_addr) {
+  if (resolved_addr->len == 0) {
+    return absl::InvalidArgumentError("Empty address");
+  }
   grpc_resolved_address addr_normalized;
   if (grpc_sockaddr_is_v4mapped(resolved_addr, &addr_normalized)) {
     resolved_addr = &addr_normalized;
@@ -236,13 +271,11 @@ std::string grpc_sockaddr_to_uri(const grpc_resolved_address* resolved_addr) {
   if (scheme == nullptr || strcmp("unix", scheme) == 0) {
     return grpc_sockaddr_to_uri_unix_if_possible(resolved_addr);
   }
-  std::string path =
-      grpc_sockaddr_to_string(resolved_addr, false /* normalize */);
-  std::string uri_str;
-  if (scheme != nullptr) {
-    uri_str = absl::StrCat(scheme, ":", path);
-  }
-  return uri_str;
+  // TODO(anramach): Encode the string using URI::Create() and URI::ToString()
+  // before returning.
+  auto path = grpc_sockaddr_to_string(resolved_addr, false /* normalize */);
+  if (!path.ok()) return path;
+  return absl::StrCat(scheme, ":", path.value());
 }
 
 const char* grpc_sockaddr_get_uri_scheme(

data/src/core/lib/address_utils/sockaddr_utils.h

@@ -23,6 +23,8 @@
 
 #include <string>
 
+#include "absl/status/statusor.h"
+
 #include "src/core/lib/iomgr/resolved_address.h"
 
 /* Returns true if addr is an IPv4-mapped IPv6 address within the
@@ -60,14 +62,15 @@ int grpc_sockaddr_set_port(grpc_resolved_address* addr, int port);
 
 // Converts a sockaddr into a newly-allocated human-readable string.
 //
-// Currently, only the AF_INET and AF_INET6 families are recognized.
+// Currently, only the AF_INET, AF_INET6, and AF_UNIX families are recognized.
 // If the normalize flag is enabled, ::ffff:0.0.0.0/96 IPv6 addresses are
 // displayed as plain IPv4.
-std::string grpc_sockaddr_to_string(const grpc_resolved_address* addr,
-                                    bool normalize) GRPC_MUST_USE_RESULT;
+absl::StatusOr<std::string> grpc_sockaddr_to_string(
+    const grpc_resolved_address* addr, bool normalize) GRPC_MUST_USE_RESULT;
 
 /* Returns the URI string corresponding to \a addr */
-std::string grpc_sockaddr_to_uri(const grpc_resolved_address* addr);
+absl::StatusOr<std::string> grpc_sockaddr_to_uri(
+    const grpc_resolved_address* addr);
 
 /* Returns the URI scheme corresponding to \a addr */
 const char* grpc_sockaddr_get_uri_scheme(const grpc_resolved_address* addr);

data/src/core/lib/avl/avl.h

@@ -19,8 +19,8 @@
 
 #include <stdlib.h>
 
-#include <algorithm>
 #include <memory>
+#include <utility>
 
 #include "absl/container/inlined_vector.h"
 
@@ -89,6 +89,7 @@ class AVL {
 
  private:
   struct Node;
+
   typedef std::shared_ptr<Node> NodePtr;
   struct Node : public std::enable_shared_from_this<Node> {
     Node(K k, V v, NodePtr l, NodePtr r, long h)
@@ -309,6 +310,7 @@ class AVL<K, void> {
 
  private:
   struct Node;
+
   typedef std::shared_ptr<Node> NodePtr;
   struct Node : public std::enable_shared_from_this<Node> {
     Node(K k, NodePtr l, NodePtr r, long h)

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

@@ -17,6 +17,10 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <utility>
+
+#include "absl/utility/utility.h"
+
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/resource_quota/arena.h"

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

@@ -21,11 +21,17 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "absl/strings/string_view.h"
+#include <stdint.h>
 
-#include "src/core/lib/channel/channel_stack.h"
+#include "absl/status/status.h"
+
+#include <grpc/impl/codegen/gpr_types.h>
+#include <grpc/support/atm.h>
+
+#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/transport/byte_stream.h"
 #include "src/core/lib/transport/metadata_batch.h"
+#include "src/core/lib/transport/transport.h"
 
 namespace grpc_core {
 

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

@@ -21,12 +21,15 @@
 #include "src/core/lib/channel/channel_args.h"
 
 #include <limits.h>
+#include <stdlib.h>
 #include <string.h>
 
+#include <algorithm>
 #include <map>
 #include <vector>
 
 #include "absl/strings/match.h"
+#include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 
@@ -35,7 +38,6 @@
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
-#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/match.h"
 
@@ -160,6 +162,43 @@ void* ChannelArgs::GetVoidPointer(absl::string_view name) const {
   return absl::get<Pointer>(*v).c_pointer();
 }
 
+absl::optional<bool> ChannelArgs::GetBool(absl::string_view name) const {
+  auto* v = Get(name);
+  if (v == nullptr) return absl::nullopt;
+  auto* i = absl::get_if<int>(v);
+  if (i == nullptr) {
+    gpr_log(GPR_ERROR, "%s ignored: it must be an integer",
+            std::string(name).c_str());
+    return absl::nullopt;
+  }
+  switch (*i) {
+    case 0:
+      return false;
+    case 1:
+      return true;
+    default:
+      gpr_log(GPR_ERROR, "%s treated as bool but set to %d (assuming true)",
+              std::string(name).c_str(), *i);
+      return true;
+  }
+}
+
+std::string ChannelArgs::ToString() const {
+  std::vector<std::string> arg_strings;
+  args_.ForEach([&arg_strings](const std::string& key, const Value& value) {
+    std::string value_str;
+    if (auto* i = absl::get_if<int>(&value)) {
+      value_str = std::to_string(*i);
+    } else if (auto* s = absl::get_if<std::string>(&value)) {
+      value_str = *s;
+    } else if (auto* p = absl::get_if<Pointer>(&value)) {
+      value_str = absl::StrFormat("%p", p->c_pointer());
+    }
+    arg_strings.push_back(absl::StrCat(key, "=", value_str));
+  });
+  return absl::StrCat("{", absl::StrJoin(arg_strings, ", "), "}");
+}
+
 }  // namespace grpc_core
 
 static grpc_arg copy_arg(const grpc_arg* src) {
@@ -461,27 +500,7 @@ grpc_arg grpc_channel_arg_pointer_create(
 }
 
 std::string grpc_channel_args_string(const grpc_channel_args* args) {
-  if (args == nullptr) return "";
-  std::vector<std::string> arg_strings;
-  for (size_t i = 0; i < args->num_args; ++i) {
-    const grpc_arg& arg = args->args[i];
-    std::string arg_string;
-    switch (arg.type) {
-      case GRPC_ARG_INTEGER:
-        arg_string = absl::StrFormat("%s=%d", arg.key, arg.value.integer);
-        break;
-      case GRPC_ARG_STRING:
-        arg_string = absl::StrFormat("%s=%s", arg.key, arg.value.string);
-        break;
-      case GRPC_ARG_POINTER:
-        arg_string = absl::StrFormat("%s=%p", arg.key, arg.value.pointer.p);
-        break;
-      default:
-        arg_string = "arg with unknown type";
-    }
-    arg_strings.push_back(arg_string);
-  }
-  return absl::StrJoin(arg_strings, ", ");
+  return grpc_core::ChannelArgs::FromC(args).ToString();
 }
 
 namespace grpc_core {

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

@@ -21,12 +21,16 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stddef.h>
+
 #include <string>
+#include <type_traits>
+#include <utility>
 
+#include "absl/meta/type_traits.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 #include "absl/types/variant.h"
-#include "absl/utility/utility.h"
 
 #include <grpc/impl/codegen/grpc_types.h>
 
@@ -81,6 +85,11 @@ struct ChannelArgTypeTraits<
   };
 };
 
+// If a type declares some member 'struct RawPointerChannelArgTag {}' then
+// we automatically generate a vtable for it that does not do any ownership
+// management and compares the type by pointer identity.
+// This is intended to be relatively ugly because *most types should worry about
+// ownership*.
 template <typename T>
 struct ChannelArgTypeTraits<T,
                             absl::void_t<typename T::RawPointerChannelArgTag>> {
@@ -191,6 +200,11 @@ class ChannelArgs {
                 ChannelArgTypeTraits<
                     absl::remove_cvref_t<decltype(*store_value)>>::VTable()));
   }
+  template <typename T>
+  GRPC_MUST_USE_RESULT ChannelArgs SetIfUnset(absl::string_view name, T value) {
+    if (Contains(name)) return *this;
+    return Set(name, std::move(value));
+  }
   GRPC_MUST_USE_RESULT ChannelArgs Remove(absl::string_view name) const;
   bool Contains(absl::string_view name) const { return Get(name) != nullptr; }
 
@@ -203,6 +217,7 @@ class ChannelArgs {
   }
   absl::optional<Duration> GetDurationFromIntMillis(
       absl::string_view name) const;
+  absl::optional<bool> GetBool(absl::string_view name) const;
 
   // Object based get/set.
   // Deal with the common case that we set a pointer to an object under
@@ -221,12 +236,26 @@ class ChannelArgs {
   T* GetObject() {
     return GetPointer<T>(T::ChannelArgName());
   }
+  template <typename T>
+  RefCountedPtr<T> GetObjectRef() {
+    auto* p = GetObject<T>();
+    if (p == nullptr) return nullptr;
+    return p->Ref();
+  }
 
   bool operator<(const ChannelArgs& other) const { return args_ < other.args_; }
   bool operator==(const ChannelArgs& other) const {
     return args_ == other.args_;
   }
 
+  // Helpers for commonly accessed things
+
+  bool WantMinimalStack() const {
+    return GetBool(GRPC_ARG_MINIMAL_STACK).value_or(false);
+  }
+
+  std::string ToString() const;
+
  private:
   explicit ChannelArgs(AVL<std::string, Value> args) : args_(std::move(args)) {}
 
@@ -333,8 +362,9 @@ ChannelArgs ChannelArgsBuiltinPrecondition(const grpc_channel_args* src);
 }  // namespace grpc_core
 
 // Takes ownership of the old_args
-typedef grpc_channel_args* (*grpc_channel_args_client_channel_creation_mutator)(
-    const char* target, grpc_channel_args* old_args,
+typedef grpc_core::ChannelArgs (
+    *grpc_channel_args_client_channel_creation_mutator)(
+    const char* target, grpc_core::ChannelArgs old_args,
     grpc_channel_stack_type type);
 
 // Should be called only once globaly before grpc is init'ed.

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

@@ -16,7 +16,7 @@
 
 #include "src/core/lib/channel/channel_args_preconditioning.h"
 
-#include <grpc/support/alloc.h>
+#include <utility>
 
 namespace grpc_core {
 
@@ -30,13 +30,13 @@ ChannelArgsPreconditioning ChannelArgsPreconditioning::Builder::Build() {
   return preconditioning;
 }
 
-const grpc_channel_args* ChannelArgsPreconditioning::PreconditionChannelArgs(
+ChannelArgs ChannelArgsPreconditioning::PreconditionChannelArgs(
     const grpc_channel_args* args) const {
   ChannelArgs channel_args = ChannelArgsBuiltinPrecondition(args);
   for (auto& stage : stages_) {
     channel_args = stage(std::move(channel_args));
   }
-  return channel_args.ToC();
+  return channel_args;
 }
 
 }  // namespace grpc_core

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

@@ -20,6 +20,8 @@
 #include <functional>
 #include <vector>
 
+#include <grpc/impl/codegen/grpc_types.h>
+
 #include "src/core/lib/channel/channel_args.h"
 
 namespace grpc_core {
@@ -49,8 +51,7 @@ class ChannelArgsPreconditioning {
   // Take channel args and precondition them.
   // Does not take ownership of the channel args passed in.
   // Returns a new channel args object that is owned by the caller.
-  const grpc_channel_args* PreconditionChannelArgs(
-      const grpc_channel_args* args) const;
+  ChannelArgs PreconditionChannelArgs(const grpc_channel_args* args) const;
 
  private:
   std::vector<Stage> stages_;

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

@@ -20,13 +20,14 @@
 
 #include "src/core/lib/channel/channel_stack.h"
 
-#include <stdlib.h>
-#include <string.h>
+#include <stdint.h>
+
+#include <utility>
 
-#include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/gpr/alloc.h"
+#include "src/core/lib/promise/poll.h"
 
 grpc_core::TraceFlag grpc_trace_channel(false, "channel");
 grpc_core::TraceFlag grpc_trace_channel_stack(false, "channel_stack");
@@ -113,6 +114,8 @@ grpc_error_handle grpc_channel_stack_init(
     }
   }
 
+  stack->on_destroy.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));
@@ -169,6 +172,9 @@ void grpc_channel_stack_destroy(grpc_channel_stack* stack) {
   for (i = 0; i < count; i++) {
     channel_elems[i].filter->destroy_channel_elem(&channel_elems[i]);
   }
+
+  (*stack->on_destroy)();
+  stack->on_destroy.Destroy();
 }
 
 grpc_error_handle grpc_call_stack_init(
@@ -272,3 +278,35 @@ grpc_call_stack* grpc_call_stack_from_top_element(grpc_call_element* elem) {
       reinterpret_cast<char*>(elem) -
       GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_call_stack)));
 }
+
+void grpc_channel_stack_no_post_init(grpc_channel_stack*,
+                                     grpc_channel_element*) {}
+
+namespace {
+
+grpc_core::NextPromiseFactory ClientNext(grpc_channel_element* elem) {
+  return [elem](grpc_core::CallArgs args) {
+    return elem->filter->make_call_promise(elem, std::move(args),
+                                           ClientNext(elem + 1));
+  };
+}
+
+grpc_core::NextPromiseFactory ServerNext(grpc_channel_element* elem) {
+  return [elem](grpc_core::CallArgs args) {
+    return elem->filter->make_call_promise(elem, std::move(args),
+                                           ServerNext(elem - 1));
+  };
+}
+
+}  // namespace
+
+grpc_core::ArenaPromise<grpc_core::ServerMetadataHandle>
+grpc_channel_stack::MakeCallPromise(grpc_core::CallArgs call_args) {
+  if (is_client) {
+    return ClientNext(grpc_channel_stack_element(this, 0))(
+        std::move(call_args));
+  } else {
+    return ServerNext(grpc_channel_stack_element(this, this->count - 1))(
+        std::move(call_args));
+  }
+}

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

@@ -50,19 +50,31 @@
 
 #include <functional>
 
-#include <grpc/grpc.h>
+#include <grpc/impl/codegen/gpr_types.h>
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/slice.h>
+#include <grpc/status.h>
 #include <grpc/support/log.h>
-#include <grpc/support/time.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/manual_constructor.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/call_combiner.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/error.h"
 #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/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 
+struct grpc_call_element;
+struct grpc_call_stack;
+struct grpc_channel_element;
+struct grpc_channel_stack;
+
 typedef struct grpc_channel_element grpc_channel_element;
 typedef struct grpc_call_element grpc_call_element;
 
@@ -164,6 +176,10 @@ struct grpc_channel_filter {
      Implementations may assume that elem->channel_data is all zeros. */
   grpc_error_handle (*init_channel_elem)(grpc_channel_element* elem,
                                          grpc_channel_element_args* args);
+  /* Post init per-channel data.
+     Called after all channel elements have been successfully created. */
+  void (*post_init_channel_elem)(grpc_channel_stack* stk,
+                                 grpc_channel_element* elem);
   /* Destroy per channel data.
      The filter does not need to do any chaining */
   void (*destroy_channel_elem)(grpc_channel_element* elem);
@@ -195,10 +211,16 @@ struct grpc_call_element {
    guarantees they live within a single malloc() allocation */
 struct grpc_channel_stack {
   grpc_stream_refcount refcount;
+  bool is_client;
   size_t count;
   /* Memory required for a call stack (computed at channel stack
      initialization) */
   size_t call_stack_size;
+  // TODO(ctiller): remove this mechanism... it's a hack to allow
+  // Channel to be separated from grpc_channel_stack's allocation. As the
+  // promise conversion continues, we'll reconsider what grpc_channel_stack
+  // should look like and this can go.
+  grpc_core::ManualConstructor<std::function<void()>> on_destroy;
 
   // Minimal infrastructure to act like a RefCounted thing without converting
   // everything.
@@ -211,6 +233,9 @@ struct grpc_channel_stack {
     IncrementRefCount();
     return grpc_core::RefCountedPtr<grpc_channel_stack>(this);
   }
+
+  grpc_core::ArenaPromise<grpc_core::ServerMetadataHandle> MakeCallPromise(
+      grpc_core::CallArgs call_args);
 };
 
 /* A call stack tracks a set of related filters for one call, and guarantees
@@ -222,6 +247,16 @@ struct grpc_call_stack {
      about the address of the call stack itself. */
   grpc_stream_refcount refcount;
   size_t count;
+
+  // Minimal infrastructure to act like a RefCounted thing without converting
+  // everything.
+  // grpc_call_stack will be eliminated once the promise conversion completes.
+  void IncrementRefCount();
+  void Unref();
+  grpc_core::RefCountedPtr<grpc_call_stack> Ref() {
+    IncrementRefCount();
+    return grpc_core::RefCountedPtr<grpc_call_stack>(this);
+  }
 };
 
 /* Get a channel element given a channel stack and its index */
@@ -304,6 +339,14 @@ inline void grpc_channel_stack::Unref() {
   GRPC_CHANNEL_STACK_UNREF(this, "smart_pointer");
 }
 
+inline void grpc_call_stack::IncrementRefCount() {
+  GRPC_CALL_STACK_REF(this, "smart_pointer");
+}
+
+inline void grpc_call_stack::Unref() {
+  GRPC_CALL_STACK_UNREF(this, "smart_pointer");
+}
+
 /* Destroy a call stack */
 void grpc_call_stack_destroy(grpc_call_stack* stack,
                              const grpc_call_final_info* final_info,
@@ -333,6 +376,9 @@ void grpc_call_log_op(const char* file, int line, gpr_log_severity severity,
                       grpc_call_element* elem,
                       grpc_transport_stream_op_batch* op);
 
+void grpc_channel_stack_no_post_init(grpc_channel_stack* stk,
+                                     grpc_channel_element* elem);
+
 extern grpc_core::TraceFlag grpc_trace_channel;
 
 #define GRPC_CALL_LOG_OP(sev, elem, op)                \