grpc 1.43.1 → 1.45.0

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

@@ -37,6 +37,7 @@
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
+#include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/iomgr/grpc_if_nametoindex.h"
@@ -318,3 +319,22 @@ uint16_t grpc_strhtons(const char* port) {
   }
   return htons(static_cast<unsigned short>(atoi(port)));
 }
+
+grpc_error_handle grpc_string_to_sockaddr(grpc_resolved_address* out,
+                                          const char* addr, int port) {
+  memset(out, 0, sizeof(grpc_resolved_address));
+  grpc_sockaddr_in6* addr6 = reinterpret_cast<grpc_sockaddr_in6*>(out->addr);
+  grpc_sockaddr_in* addr4 = reinterpret_cast<grpc_sockaddr_in*>(out->addr);
+  if (grpc_inet_pton(GRPC_AF_INET6, addr, &addr6->sin6_addr) == 1) {
+    addr6->sin6_family = GRPC_AF_INET6;
+    out->len = sizeof(grpc_sockaddr_in6);
+  } else if (grpc_inet_pton(GRPC_AF_INET, addr, &addr4->sin_addr) == 1) {
+    addr4->sin_family = GRPC_AF_INET;
+    out->len = sizeof(grpc_sockaddr_in);
+  } else {
+    return GRPC_ERROR_CREATE_FROM_CPP_STRING(
+        absl::StrCat("Failed to parse address:", addr));
+  }
+  grpc_sockaddr_set_port(out, port);
+  return GRPC_ERROR_NONE;
+}

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

@@ -61,6 +61,11 @@ bool grpc_parse_ipv6_hostport(absl::string_view hostport,
 /* Converts named or numeric port to a uint16 suitable for use in a sockaddr. */
 uint16_t grpc_strhtons(const char* port);
 
+// Newer form of grpc_string_to_sockaddr which returns an error instead of
+// crashing if \a addr is not IPv6/IPv6
+grpc_error_handle grpc_string_to_sockaddr(grpc_resolved_address* out,
+                                          const char* addr, int port);
+
 namespace grpc_core {
 
 /** Populate \a resolved_addr to be a unix socket at |path| */

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

@@ -29,16 +29,42 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 
-#include <grpc/event_engine/event_engine.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/host_port.h"
-#include "src/core/lib/iomgr/event_engine/resolved_address_internal.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/socket_utils.h"
-#include "src/core/lib/iomgr/unix_sockets_posix.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(
+    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 "";
+  }
+  const auto* unix_addr = reinterpret_cast<const struct sockaddr_un*>(addr);
+  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));
+  }
+  return absl::StrCat("unix:", unix_addr->sun_path);
+}
+#else
+static std::string grpc_sockaddr_to_uri_unix_if_possible(
+    const grpc_resolved_address* /* addr */) {
+  return "";
+}
+#endif
 
 static const uint8_t kV4MappedPrefix[] = {0, 0, 0, 0, 0,    0,
                                           0, 0, 0, 0, 0xff, 0xff};
@@ -200,25 +226,6 @@ std::string grpc_sockaddr_to_string(const grpc_resolved_address* resolved_addr,
   return out;
 }
 
-grpc_error_handle grpc_string_to_sockaddr(grpc_resolved_address* out,
-                                          const char* addr, int port) {
-  memset(out, 0, sizeof(grpc_resolved_address));
-  grpc_sockaddr_in6* addr6 = reinterpret_cast<grpc_sockaddr_in6*>(out->addr);
-  grpc_sockaddr_in* addr4 = reinterpret_cast<grpc_sockaddr_in*>(out->addr);
-  if (grpc_inet_pton(GRPC_AF_INET6, addr, &addr6->sin6_addr) == 1) {
-    addr6->sin6_family = GRPC_AF_INET6;
-    out->len = sizeof(grpc_sockaddr_in6);
-  } else if (grpc_inet_pton(GRPC_AF_INET, addr, &addr4->sin_addr) == 1) {
-    addr4->sin_family = GRPC_AF_INET;
-    out->len = sizeof(grpc_sockaddr_in);
-  } else {
-    return GRPC_ERROR_CREATE_FROM_CPP_STRING(
-        absl::StrCat("Failed to parse address:", addr));
-  }
-  grpc_sockaddr_set_port(out, port);
-  return GRPC_ERROR_NONE;
-}
-
 std::string grpc_sockaddr_to_uri(const grpc_resolved_address* resolved_addr) {
   if (resolved_addr->len == 0) return "";
   grpc_resolved_address addr_normalized;
@@ -269,10 +276,11 @@ int grpc_sockaddr_get_port(const grpc_resolved_address* resolved_addr) {
     case GRPC_AF_INET6:
       return grpc_ntohs(
           (reinterpret_cast<const grpc_sockaddr_in6*>(addr))->sin6_port);
+#ifdef GRPC_HAVE_UNIX_SOCKET
+    case AF_UNIX:
+      return 1;
+#endif
     default:
-      if (grpc_is_unix_socket(resolved_addr)) {
-        return 1;
-      }
       gpr_log(GPR_ERROR, "Unknown socket family %d in grpc_sockaddr_get_port",
               addr->sa_family);
       return 0;
@@ -399,14 +407,3 @@ bool grpc_sockaddr_match_subnet(const grpc_resolved_address* address,
   }
   return false;
 }
-
-namespace grpc_event_engine {
-namespace experimental {
-
-std::string ResolvedAddressToURI(const EventEngine::ResolvedAddress& addr) {
-  auto gra = CreateGRPCResolvedAddress(addr);
-  return grpc_sockaddr_to_uri(&gra);
-}
-
-}  // namespace experimental
-}  // namespace grpc_event_engine

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

@@ -23,9 +23,7 @@
 
 #include <string>
 
-#include <grpc/event_engine/event_engine.h>
-
-#include "src/core/lib/iomgr/resolve_address.h"
+#include "src/core/lib/iomgr/resolved_address.h"
 
 /* Returns true if addr is an IPv4-mapped IPv6 address within the
    ::ffff:0.0.0.0/96 range, or false otherwise.
@@ -68,11 +66,6 @@ int grpc_sockaddr_set_port(grpc_resolved_address* addr, int port);
 std::string grpc_sockaddr_to_string(const grpc_resolved_address* addr,
                                     bool normalize) GRPC_MUST_USE_RESULT;
 
-// Newer form of grpc_string_to_sockaddr which returns an error instead of
-// crashing if \a addr is not IPv6/IPv6
-grpc_error_handle grpc_string_to_sockaddr(grpc_resolved_address* out,
-                                          const char* addr, int port);
-
 /* Returns the URI string corresponding to \a addr */
 std::string grpc_sockaddr_to_uri(const grpc_resolved_address* addr);
 
@@ -99,12 +92,4 @@ bool grpc_sockaddr_match_subnet(const grpc_resolved_address* address,
                                 const grpc_resolved_address* subnet_address,
                                 uint32_t mask_bits);
 
-namespace grpc_event_engine {
-namespace experimental {
-
-std::string ResolvedAddressToURI(const EventEngine::ResolvedAddress& addr);
-
-}  // namespace experimental
-}  // namespace grpc_event_engine
-
 #endif /* GRPC_CORE_LIB_ADDRESS_UTILS_SOCKADDR_UTILS_H */

data/src/core/lib/backoff/backoff.cc

@@ -26,46 +26,19 @@
 
 namespace grpc_core {
 
-namespace {
+BackOff::BackOff(const Options& options) : options_(options) { Reset(); }
 
-/* Generate a random number between 0 and 1. We roll our own RNG because seeding
- * rand() modifies a global variable we have no control over. */
-double generate_uniform_random_number(uint32_t* rng_state) {
-  constexpr uint32_t two_raise_31 = uint32_t(1) << 31;
-  *rng_state = (1103515245 * *rng_state + 12345) % two_raise_31;
-  return *rng_state / static_cast<double>(two_raise_31);
-}
-
-double generate_uniform_random_number_between(uint32_t* rng_state, double a,
-                                              double b) {
-  if (a == b) return a;
-  if (a > b) std::swap(a, b);  // make sure a < b
-  const double range = b - a;
-  return a + generate_uniform_random_number(rng_state) * range;
-}
-
-}  // namespace
-
-BackOff::BackOff(const Options& options)
-    : options_(options),
-      rng_state_(static_cast<uint32_t>(gpr_now(GPR_CLOCK_REALTIME).tv_nsec)) {
-  Reset();
-}
-
-grpc_millis BackOff::NextAttemptTime() {
+Timestamp BackOff::NextAttemptTime() {
   if (initial_) {
     initial_ = false;
     return current_backoff_ + ExecCtx::Get()->Now();
   }
-  current_backoff_ = static_cast<grpc_millis>(
-      std::min(current_backoff_ * options_.multiplier(),
-               static_cast<double>(options_.max_backoff())));
-  const double jitter = generate_uniform_random_number_between(
-      &rng_state_, -options_.jitter() * current_backoff_,
-      options_.jitter() * current_backoff_);
-  const grpc_millis next_timeout =
-      static_cast<grpc_millis>(current_backoff_ + jitter);
-  return next_timeout + ExecCtx::Get()->Now();
+  current_backoff_ = std::min(current_backoff_ * options_.multiplier(),
+                              options_.max_backoff());
+  const Duration jitter = Duration::FromSecondsAsDouble(
+      absl::Uniform(rand_gen_, -options_.jitter() * current_backoff_.seconds(),
+                    options_.jitter() * current_backoff_.seconds()));
+  return ExecCtx::Get()->Now() + current_backoff_ + jitter;
 }
 
 void BackOff::Reset() {
@@ -73,6 +46,4 @@ void BackOff::Reset() {
   initial_ = true;
 }
 
-void BackOff::SetRandomSeed(uint32_t seed) { rng_state_ = seed; }
-
 }  // namespace grpc_core

data/src/core/lib/backoff/backoff.h

@@ -21,6 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "absl/random/random.h"
+
 #include "src/core/lib/iomgr/exec_ctx.h"
 
 namespace grpc_core {
@@ -35,17 +37,15 @@ class BackOff {
   explicit BackOff(const Options& options);
 
   /// Returns the time at which the next attempt should start.
-  grpc_millis NextAttemptTime();
+  Timestamp NextAttemptTime();
 
   /// Reset the backoff, so the next value returned by NextAttemptTime()
   /// will be the time of the second attempt (rather than the Nth).
   void Reset();
 
-  void SetRandomSeed(unsigned int seed);
-
   class Options {
    public:
-    Options& set_initial_backoff(grpc_millis initial_backoff) {
+    Options& set_initial_backoff(Duration initial_backoff) {
       initial_backoff_ = initial_backoff;
       return *this;
     }
@@ -57,32 +57,32 @@ class BackOff {
       jitter_ = jitter;
       return *this;
     }
-    Options& set_max_backoff(grpc_millis max_backoff) {
+    Options& set_max_backoff(Duration max_backoff) {
       max_backoff_ = max_backoff;
       return *this;
     }
     /// how long to wait after the first failure before retrying
-    grpc_millis initial_backoff() const { return initial_backoff_; }
+    Duration initial_backoff() const { return initial_backoff_; }
     /// factor with which to multiply backoff after a failed retry
     double multiplier() const { return multiplier_; }
     /// amount to randomize backoffs
     double jitter() const { return jitter_; }
     /// maximum time between retries
-    grpc_millis max_backoff() const { return max_backoff_; }
+    Duration max_backoff() const { return max_backoff_; }
 
    private:
-    grpc_millis initial_backoff_;
+    Duration initial_backoff_;
     double multiplier_;
     double jitter_;
-    grpc_millis max_backoff_;
+    Duration max_backoff_;
   };  // class Options
 
  private:
   const Options options_;
-  uint32_t rng_state_;
+  absl::BitGen rand_gen_;
   bool initial_;
   /// current delay before retries
-  grpc_millis current_backoff_;
+  Duration current_backoff_;
 };
 
 }  // namespace grpc_core

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

@@ -0,0 +1,86 @@
+// Copyright 2022 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.
+
+#ifndef GRPC_CORE_LIB_CHANNEL_CALL_FINALIZATION_H
+#define GRPC_CORE_LIB_CHANNEL_CALL_FINALIZATION_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/promise/context.h"
+#include "src/core/lib/resource_quota/arena.h"
+
+namespace grpc_core {
+
+// Call finalization context.
+// Sometimes a filter needs to perform some operation after the last byte of
+// data is flushed to the wire. This context is used to perform that
+// finalization.
+// Filters can register a finalizer by calling Add().
+// The finalizer will be called before the call is destroyed but after
+// the top level promise is completed.
+class CallFinalization {
+ public:
+  // Add a step to the finalization context.
+  // Takes a callable with a signature compatible with:
+  // (const grpc_call_final_info&) -> void.
+  // Finalizers are run in the reverse order they are added.
+  template <typename F>
+  void Add(F&& t) {
+    first_ =
+        GetContext<Arena>()->New<FuncFinalizer<F>>(std::forward<F>(t), first_);
+  }
+
+  void Run(const grpc_call_final_info* final_info) {
+    if (Finalizer* f = absl::exchange(first_, nullptr)) f->Run(final_info);
+  }
+
+ private:
+  // Base class for finalizer implementations.
+  class Finalizer {
+   public:
+    // Run the finalizer and call the destructor of this Finalizer.
+    virtual void Run(const grpc_call_final_info* final_info) = 0;
+
+   protected:
+    ~Finalizer() {}
+  };
+  // Specialization for callable objects.
+  template <typename F>
+  class FuncFinalizer final : public Finalizer {
+   public:
+    FuncFinalizer(F&& f, Finalizer* next)
+        : next_(next), f_(std::forward<F>(f)) {}
+
+    void Run(const grpc_call_final_info* final_info) override {
+      f_(final_info);
+      Finalizer* next = next_;
+      this->~FuncFinalizer();
+      if (next != nullptr) next->Run(final_info);
+    }
+
+   private:
+    Finalizer* next_;
+    F f_;
+  };
+  // The first finalizer in the chain.
+  Finalizer* first_ = nullptr;
+};
+
+template <>
+struct ContextType<CallFinalization> {};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_CHANNEL_CALL_FINALIZATION_H

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

@@ -23,6 +23,7 @@
 #include <limits.h>
 #include <string.h>
 
+#include <map>
 #include <vector>
 
 #include "absl/strings/match.h"
@@ -30,7 +31,6 @@
 #include "absl/strings/str_join.h"
 
 #include <grpc/impl/codegen/grpc_types.h>
-#include <grpc/impl/codegen/log.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
@@ -383,6 +383,65 @@ const grpc_channel_args* RemoveGrpcInternalArgs(const grpc_channel_args* src) {
   }
   return dst;
 }
+
+const grpc_channel_args* UniquifyChannelArgKeys(const grpc_channel_args* src) {
+  if (src == nullptr) return nullptr;
+  std::map<absl::string_view, const grpc_arg*> values;
+  std::map<absl::string_view, std::vector<std::string>> concatenated_values;
+  for (size_t i = 0; i < src->num_args; i++) {
+    absl::string_view key = src->args[i].key;
+    // User-agent strings were traditionally multi-valued and concatenated.
+    // We preserve this behavior for backwards compatibility.
+    if (key == GRPC_ARG_PRIMARY_USER_AGENT_STRING ||
+        key == GRPC_ARG_SECONDARY_USER_AGENT_STRING) {
+      if (src->args[i].type != GRPC_ARG_STRING) {
+        gpr_log(GPR_ERROR, "Channel argument '%s' should be a string",
+                std::string(key).c_str());
+      } else {
+        concatenated_values[key].push_back(src->args[i].value.string);
+      }
+      continue;
+    }
+    auto it = values.find(key);
+    if (it == values.end()) {
+      values[key] = &src->args[i];
+    } else {
+      // Traditional grpc_channel_args_find behavior was to pick the first
+      // value.
+      // For compatibility with existing users, we will do the same here.
+    }
+  }
+  if (values.size() + concatenated_values.size() == src->num_args) {
+    return grpc_channel_args_copy(src);
+  }
+  // Concatenate the concatenated values.
+  std::map<absl::string_view, std::string> concatenated_values_str;
+  for (const auto& concatenated_value : concatenated_values) {
+    concatenated_values_str[concatenated_value.first] =
+        absl::StrJoin(concatenated_value.second, " ");
+  }
+  // Create the result
+  std::vector<grpc_arg> argv;
+  argv.reserve(values.size());
+  for (const auto& a : values) {
+    argv.push_back(*a.second);
+  }
+  for (const auto& a : concatenated_values_str) {
+    argv.push_back(
+        grpc_channel_arg_string_create(const_cast<char*>(a.first.data()),
+                                       const_cast<char*>(a.second.c_str())));
+  }
+  grpc_channel_args args = {argv.size(), argv.data()};
+  // Log that we're mutating things
+  gpr_log(GPR_INFO,
+          "Uniquification pass on channel args is mutating them: {%s} is being "
+          "changed to {%s}",
+          grpc_channel_args_string(src).c_str(),
+          grpc_channel_args_string(&args).c_str());
+  // Return the result (note we need to copy because we're borrowing the args
+  // from src still!)
+  return grpc_channel_args_copy(&args);
+}
 }  // namespace grpc_core
 
 namespace {

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

@@ -127,6 +127,8 @@ namespace grpc_core {
  *  Does not take ownership of \a src.
  *  Should be called by any public API that receives channel args. */
 const grpc_channel_args* RemoveGrpcInternalArgs(const grpc_channel_args* src);
+/** Ensure no duplicate channel args, in preparation for moving to a map<> */
+const grpc_channel_args* UniquifyChannelArgKeys(const grpc_channel_args* src);
 }  // namespace grpc_core
 
 // Takes ownership of the old_args

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

@@ -27,6 +27,7 @@ void ChannelArgsPreconditioning::Builder::RegisterStage(Stage stage) {
 ChannelArgsPreconditioning ChannelArgsPreconditioning::Builder::Build() {
   // TODO(ctiller): should probably make this registered too.
   stages_.emplace_back(RemoveGrpcInternalArgs);
+  stages_.emplace_back(UniquifyChannelArgKeys);
 
   ChannelArgsPreconditioning preconditioning;
   preconditioning.stages_ = std::move(stages_);

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

@@ -29,6 +29,7 @@
 #include "src/core/lib/gpr/alloc.h"
 
 grpc_core::TraceFlag grpc_trace_channel(false, "channel");
+grpc_core::TraceFlag grpc_trace_channel_stack(false, "channel_stack");
 
 /* Memory layouts.
 
@@ -103,8 +104,15 @@ grpc_call_element* grpc_call_stack_element(grpc_call_stack* call_stack,
 grpc_error_handle grpc_channel_stack_init(
     int initial_refs, grpc_iomgr_cb_func destroy, void* destroy_arg,
     const grpc_channel_filter** filters, size_t filter_count,
-    const grpc_channel_args* channel_args, grpc_transport* optional_transport,
-    const char* name, grpc_channel_stack* stack) {
+    const grpc_channel_args* channel_args, const char* name,
+    grpc_channel_stack* stack) {
+  if (grpc_trace_channel_stack.enabled()) {
+    gpr_log(GPR_INFO, "CHANNEL_STACK: init %s", name);
+    for (size_t i = 0; i < filter_count; i++) {
+      gpr_log(GPR_INFO, "CHANNEL_STACK:   filter %s", filters[i]->name);
+    }
+  }
+
   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));
@@ -126,7 +134,6 @@ grpc_error_handle grpc_channel_stack_init(
   for (i = 0; i < filter_count; i++) {
     args.channel_stack = stack;
     args.channel_args = channel_args;
-    args.optional_transport = optional_transport;
     args.is_first = i == 0;
     args.is_last = i == (filter_count - 1);
     elems[i].filter = filters[i];

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

@@ -48,15 +48,19 @@
 
 #include <stddef.h>
 
+#include <functional>
+
 #include <grpc/grpc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/time.h>
 
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gpr/time_precise.h"
-#include "src/core/lib/gprpp/arena.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/call_combiner.h"
 #include "src/core/lib/iomgr/polling_entity.h"
+#include "src/core/lib/resource_quota/arena.h"
+#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 
 typedef struct grpc_channel_element grpc_channel_element;
@@ -65,11 +69,11 @@ typedef struct grpc_call_element grpc_call_element;
 typedef struct grpc_channel_stack grpc_channel_stack;
 typedef struct grpc_call_stack grpc_call_stack;
 
+#define GRPC_ARG_TRANSPORT "grpc.internal.transport"
+
 struct grpc_channel_element_args {
   grpc_channel_stack* channel_stack;
   const grpc_channel_args* channel_args;
-  /** Transport, iff it is known */
-  grpc_transport* optional_transport;
   int is_first;
   int is_last;
 };
@@ -79,7 +83,7 @@ struct grpc_call_element_args {
   grpc_call_context_element* context;
   const grpc_slice& path;
   gpr_cycle_counter start_time;  // Note: not populated in subchannel stack.
-  grpc_millis deadline;
+  grpc_core::Timestamp deadline;
   grpc_core::Arena* arena;
   grpc_core::CallCombiner* call_combiner;
 };
@@ -109,6 +113,19 @@ struct grpc_channel_filter {
      See grpc_call_next_op on how to call the next element in the stack */
   void (*start_transport_stream_op_batch)(grpc_call_element* elem,
                                           grpc_transport_stream_op_batch* op);
+  /* Create a promise to execute one call.
+     If this is non-null, it may be used in preference to
+     start_transport_stream_op_batch.
+     If this is used in preference to start_transport_stream_op_batch, the
+     following can be omitted also:
+       - calling init_call_elem, destroy_call_elem, set_pollset_or_pollset_set
+       - allocation of memory for call data
+     There is an on-going migration to move all filters to providing this, and
+     then to drop start_transport_stream_op_batch. */
+  grpc_core::ArenaPromise<grpc_core::TrailingMetadata> (*make_call_promise)(
+      grpc_channel_element* elem,
+      grpc_core::ClientInitialMetadata initial_metadata,
+      grpc_core::NextPromiseFactory next_promise_factory);
   /* Called to handle channel level operations - e.g. new calls, or transport
      closure.
      See grpc_channel_next_op on how to call the next element in the stack */
@@ -185,6 +202,18 @@ struct grpc_channel_stack {
   /* Memory required for a call stack (computed at channel stack
      initialization) */
   size_t call_stack_size;
+
+  // Minimal infrastructure to act like a RefCounted thing without converting
+  // everything.
+  // It's likely that we'll want to replace grpc_channel_stack with something
+  // less regimented once the promise conversion completes, so avoiding doing a
+  // full C++-ification for now.
+  void IncrementRefCount();
+  void Unref();
+  grpc_core::RefCountedPtr<grpc_channel_stack> Ref() {
+    IncrementRefCount();
+    return grpc_core::RefCountedPtr<grpc_channel_stack>(this);
+  }
 };
 
 /* A call stack tracks a set of related filters for one call, and guarantees
@@ -221,8 +250,7 @@ size_t grpc_channel_stack_size(const grpc_channel_filter** filters,
 grpc_error_handle grpc_channel_stack_init(
     int initial_refs, grpc_iomgr_cb_func destroy, void* destroy_arg,
     const grpc_channel_filter** filters, size_t filter_count,
-    const grpc_channel_args* args, grpc_transport* optional_transport,
-    const char* name, grpc_channel_stack* stack);
+    const grpc_channel_args* args, const char* name, grpc_channel_stack* stack);
 /* Destroy a channel stack */
 void grpc_channel_stack_destroy(grpc_channel_stack* stack);
 
@@ -271,6 +299,14 @@ void grpc_call_stack_set_pollset_or_pollset_set(grpc_call_stack* call_stack,
   } while (0);
 #endif
 
+inline void grpc_channel_stack::IncrementRefCount() {
+  GRPC_CHANNEL_STACK_REF(this, "smart_pointer");
+}
+
+inline void grpc_channel_stack::Unref() {
+  GRPC_CHANNEL_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,