grpc 1.54.3 → 1.59.2

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

@@ -38,12 +38,12 @@
 #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"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
-#include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/resource_quota/arena.h"
@@ -73,6 +73,7 @@ typedef struct grpc_call_create_args {
   absl::optional<grpc_core::Slice> authority;
 
   grpc_core::Timestamp send_deadline;
+  bool registered_method;  // client_only
 } grpc_call_create_args;
 
 namespace grpc_core {
@@ -107,6 +108,7 @@ class CallContext {
 
   // 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
@@ -126,7 +128,7 @@ class CallContext {
 
   grpc_call_stats* call_stats() { return &call_stats_; }
   gpr_atm* peer_string_atm_ptr();
-  grpc_polling_entity* polling_entity() { return &pollent_; }
+  gpr_cycle_counter call_start_time() { return start_time_; }
 
   ServerCallContext* server_call_context();
 
@@ -137,12 +139,10 @@ class CallContext {
   friend class PromiseBasedCall;
   // Call final info.
   grpc_call_stats call_stats_;
-  // Pollset stuff, can't wait to remove.
-  // TODO(ctiller): bring forth EventEngine.
-  grpc_polling_entity pollent_;
   // TODO(ctiller): remove this once transport APIs are promise based and we
   // don't need refcounting here.
   PromiseBasedCall* const call_;
+  gpr_cycle_counter start_time_ = gpr_get_cycle_counter();
   // Is this call traced?
   bool traced_ = false;
 };

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

@@ -32,6 +32,7 @@
 
 #include <grpc/compression.h>
 #include <grpc/grpc.h>
+#include <grpc/impl/channel_arg_names.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/time.h>
@@ -283,7 +284,7 @@ static grpc_call* grpc_channel_create_call_internal(
     grpc_channel* c_channel, grpc_call* parent_call, uint32_t propagation_mask,
     grpc_completion_queue* cq, grpc_pollset_set* pollset_set_alternative,
     grpc_core::Slice path, absl::optional<grpc_core::Slice> authority,
-    grpc_core::Timestamp deadline) {
+    grpc_core::Timestamp deadline, bool registered_method) {
   auto channel = grpc_core::Channel::FromC(c_channel)->Ref();
   GPR_ASSERT(channel->is_client());
   GPR_ASSERT(!(cq != nullptr && pollset_set_alternative != nullptr));
@@ -299,6 +300,7 @@ static grpc_call* grpc_channel_create_call_internal(
   args.path = std::move(path);
   args.authority = std::move(authority);
   args.send_deadline = deadline;
+  args.registered_method = registered_method;
 
   grpc_call* call;
   GRPC_LOG_IF_ERROR("call_create", grpc_call_create(&args, &call));
@@ -320,7 +322,8 @@ grpc_call* grpc_channel_create_call(grpc_channel* channel,
       host != nullptr
           ? absl::optional<grpc_core::Slice>(grpc_core::CSliceRef(*host))
           : absl::nullopt,
-      grpc_core::Timestamp::FromTimespecRoundUp(deadline));
+      grpc_core::Timestamp::FromTimespecRoundUp(deadline),
+      /*registered_method=*/false);
 
   return call;
 }
@@ -336,7 +339,7 @@ grpc_call* grpc_channel_create_pollset_set_call(
       host != nullptr
           ? absl::optional<grpc_core::Slice>(grpc_core::CSliceRef(*host))
           : absl::nullopt,
-      deadline);
+      deadline, /*registered_method=*/true);
 }
 
 namespace grpc_core {
@@ -414,7 +417,8 @@ grpc_call* grpc_channel_create_registered_call(
       rc->authority.has_value()
           ? absl::optional<grpc_core::Slice>(rc->authority->Ref())
           : absl::nullopt,
-      grpc_core::Timestamp::FromTimespecRoundUp(deadline));
+      grpc_core::Timestamp::FromTimespecRoundUp(deadline),
+      /*registered_method=*/true);
 
   return call;
 }

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

@@ -21,10 +21,11 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <functional>
 #include <utility>
 #include <vector>
 
+#include "absl/functional/any_invocable.h"
+
 #include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 
@@ -41,7 +42,7 @@ class ChannelInit {
  public:
   /// One stage of mutation: call functions against \a builder to influence the
   /// finally constructed channel stack
-  using Stage = std::function<bool(ChannelStackBuilder* builder)>;
+  using Stage = absl::AnyInvocable<bool(ChannelStackBuilder* builder) const>;
 
   class Builder {
    public:

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

@@ -57,6 +57,10 @@
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/event_string.h"
 
+#ifdef GPR_WINDOWS
+#include "src/core/lib/experiments/experiments.h"
+#endif
+
 grpc_core::TraceFlag grpc_trace_operation_failures(false, "op_failure");
 grpc_core::DebugOnlyTraceFlag grpc_trace_pending_tags(false, "pending_tags");
 grpc_core::DebugOnlyTraceFlag grpc_trace_cq_refcount(false, "cq_refcount");
@@ -349,10 +353,14 @@ struct cq_callback_data {
 struct grpc_completion_queue {
   /// Once owning_refs drops to zero, we will destroy the cq
   grpc_core::RefCount owning_refs;
-
+  /// Add the paddings to fix the false sharing
+  char padding_1[GPR_CACHELINE_SIZE];
   gpr_mu* mu;
 
+  char padding_2[GPR_CACHELINE_SIZE];
   const cq_vtable* vtable;
+
+  char padding_3[GPR_CACHELINE_SIZE];
   const cq_poller_vtable* poller_vtable;
 
 #ifndef NDEBUG
@@ -539,7 +547,8 @@ grpc_completion_queue* grpc_completion_queue_create_internal(
   cq->poller_vtable = poller_vtable;
 
   // One for destroy(), one for pollset_shutdown
-  new (&cq->owning_refs) grpc_core::RefCount(2);
+  new (&cq->owning_refs) grpc_core::RefCount(
+      2, grpc_trace_cq_refcount.enabled() ? "completion_queue" : nullptr);
 
   poller_vtable->init(POLLSET_FROM_CQ(cq), &cq->mu);
   vtable->init(DATA_FROM_CQ(cq), shutdown_callback);
@@ -877,6 +886,12 @@ void grpc_cq_end_op(grpc_completion_queue* cq, void* tag,
                     void (*done)(void* done_arg, grpc_cq_completion* storage),
                     void* done_arg, grpc_cq_completion* storage,
                     bool internal) {
+// TODO(hork): remove when the listener flake is identified
+#ifdef GPR_WINDOWS
+  if (grpc_core::IsEventEngineListenerEnabled()) {
+    gpr_log(GPR_ERROR, "cq_end_op called for tag %d (0x%p)", tag, tag);
+  }
+#endif
   cq->vtable->end_op(cq, tag, error, done, done_arg, storage, internal);
 }
 
@@ -1230,7 +1245,7 @@ static grpc_event cq_pluck(grpc_completion_queue* cq, void* tag,
     prev = &cqd->completed_head;
     while ((c = reinterpret_cast<grpc_cq_completion*>(
                 prev->next & ~uintptr_t{1})) != &cqd->completed_head) {
-      if (c->tag == tag) {
+      if (GPR_LIKELY(c->tag == tag)) {
         prev->next = (prev->next & uintptr_t{1}) | (c->next & ~uintptr_t{1});
         if (c == cqd->completed_tail) {
           cqd->completed_tail = prev;

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

@@ -27,6 +27,7 @@
 #include <grpc/fork.h>
 #include <grpc/grpc.h>
 #include <grpc/grpc_security.h>
+#include <grpc/impl/channel_arg_names.h>
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>

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

@@ -28,7 +28,6 @@
 #include <list>
 #include <new>
 #include <queue>
-#include <tuple>
 #include <type_traits>
 #include <utility>
 #include <vector>
@@ -39,6 +38,8 @@
 #include "absl/types/variant.h"
 
 #include <grpc/byte_buffer.h>
+#include <grpc/grpc.h>
+#include <grpc/impl/channel_arg_names.h>
 #include <grpc/impl/connectivity_state.h>
 #include <grpc/status.h>
 #include <grpc/support/log.h>
@@ -60,13 +61,11 @@
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/context.h"
-#include "src/core/lib/promise/detail/basic_join.h"
-#include "src/core/lib/promise/detail/basic_seq.h"
 #include "src/core/lib/promise/map.h"
 #include "src/core/lib/promise/pipe.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/promise/promise.h"
-#include "src/core/lib/promise/try_join.h"
+#include "src/core/lib/promise/seq.h"
 #include "src/core/lib/promise/try_seq.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/slice/slice_internal.h"
@@ -195,9 +194,35 @@ class Server::RequestMatcherInterface {
   virtual void RequestCallWithPossiblePublish(size_t request_queue_index,
                                               RequestedCall* call) = 0;
 
-  struct MatchResult {
-    size_t cq_idx;
-    RequestedCall* requested_call;
+  class MatchResult {
+   public:
+    MatchResult(Server* server, size_t cq_idx, RequestedCall* requested_call)
+        : server_(server), cq_idx_(cq_idx), requested_call_(requested_call) {}
+    ~MatchResult() {
+      if (requested_call_ != nullptr) {
+        server_->FailCall(cq_idx_, requested_call_, absl::CancelledError());
+      }
+    }
+
+    MatchResult(const MatchResult&) = delete;
+    MatchResult& operator=(const MatchResult&) = delete;
+
+    MatchResult(MatchResult&& other) noexcept
+        : server_(other.server_),
+          cq_idx_(other.cq_idx_),
+          requested_call_(std::exchange(other.requested_call_, nullptr)) {}
+
+    RequestedCall* TakeCall() {
+      return std::exchange(requested_call_, nullptr);
+    }
+
+    grpc_completion_queue* cq() const { return server_->cqs_[cq_idx_]; }
+    size_t cq_idx() const { return cq_idx_; }
+
+   private:
+    Server* server_;
+    size_t cq_idx_;
+    RequestedCall* requested_call_;
   };
 
   // This function is invoked on an incoming promise based RPC.
@@ -294,18 +319,19 @@ class Server::RealRequestMatcher : public RequestMatcherInterface {
       while (true) {
         NextPendingCall next_pending = pop_next_pending();
         if (next_pending.rc == nullptr) break;
-        auto mr = MatchResult{request_queue_index, next_pending.rc};
         Match(
             next_pending.pending,
-            [mr](CallData* calld) {
+            [&](CallData* calld) {
               if (!calld->MaybeActivate()) {
                 // Zombied Call
                 calld->KillZombie();
               } else {
-                calld->Publish(mr.cq_idx, mr.requested_call);
+                calld->Publish(request_queue_index, next_pending.rc);
               }
             },
-            [mr](const std::shared_ptr<ActivityWaiter>& w) { w->Finish(mr); });
+            [&](const std::shared_ptr<ActivityWaiter>& w) {
+              w->Finish(server(), request_queue_index, next_pending.rc);
+            });
       }
     }
   }
@@ -357,7 +383,7 @@ class Server::RealRequestMatcher : public RequestMatcherInterface {
       RequestedCall* rc =
           reinterpret_cast<RequestedCall*>(requests_per_cq_[cq_idx].TryPop());
       if (rc != nullptr) {
-        return Immediate(MatchResult{cq_idx, rc});
+        return Immediate(MatchResult(server(), cq_idx, rc));
       }
     }
     // No cq to take the request found; queue it on the slow list.
@@ -390,18 +416,24 @@ class Server::RealRequestMatcher : public RequestMatcherInterface {
         };
       }
     }
-    return Immediate(MatchResult{cq_idx, rc});
+    return Immediate(MatchResult(server(), cq_idx, rc));
   }
 
-  Server* server() const override { return server_; }
+  Server* server() const final { return server_; }
 
  private:
   Server* const server_;
   struct ActivityWaiter {
     explicit ActivityWaiter(Waker waker) : waker(std::move(waker)) {}
     ~ActivityWaiter() { delete result.load(std::memory_order_acquire); }
-    void Finish(absl::StatusOr<MatchResult> r) {
-      result.store(new absl::StatusOr<MatchResult>(std::move(r)),
+    void Finish(absl::Status status) {
+      result.store(new absl::StatusOr<MatchResult>(std::move(status)),
+                   std::memory_order_release);
+      waker.Wakeup();
+    }
+    void Finish(Server* server, size_t cq_idx, RequestedCall* requested_call) {
+      result.store(new absl::StatusOr<MatchResult>(
+                       MatchResult(server, cq_idx, requested_call)),
                    std::memory_order_release);
       waker.Wakeup();
     }
@@ -444,7 +476,7 @@ class Server::AllocatingRequestMatcherBase : public RequestMatcherInterface {
     Crash("unreachable");
   }
 
-  Server* server() const override { return server_; }
+  Server* server() const final { return server_; }
 
   // Supply the completion queue related to this request matcher
   grpc_completion_queue* cq() const { return cq_; }
@@ -490,21 +522,14 @@ class Server::AllocatingRequestMatcherBatch
 
   ArenaPromise<absl::StatusOr<MatchResult>> MatchRequest(
       size_t /*start_request_queue_index*/) override {
-    const bool still_running = server()->ShutdownRefOnRequest();
-    auto cleanup_ref =
-        absl::MakeCleanup([this] { server()->ShutdownUnrefOnRequest(); });
-    if (still_running) {
-      BatchCallAllocation call_info = allocator_();
-      GPR_ASSERT(server()->ValidateServerRequest(
-                     cq(), static_cast<void*>(call_info.tag), nullptr,
-                     nullptr) == GRPC_CALL_OK);
-      RequestedCall* rc = new RequestedCall(
-          static_cast<void*>(call_info.tag), call_info.cq, call_info.call,
-          call_info.initial_metadata, call_info.details);
-      return Immediate(MatchResult{cq_idx(), rc});
-    } else {
-      return Immediate(absl::InternalError("Server shutdown"));
-    }
+    BatchCallAllocation call_info = allocator_();
+    GPR_ASSERT(server()->ValidateServerRequest(
+                   cq(), static_cast<void*>(call_info.tag), nullptr, nullptr) ==
+               GRPC_CALL_OK);
+    RequestedCall* rc = new RequestedCall(
+        static_cast<void*>(call_info.tag), call_info.cq, call_info.call,
+        call_info.initial_metadata, call_info.details);
+    return Immediate(MatchResult(server(), cq_idx(), rc));
   }
 
  private:
@@ -544,22 +569,14 @@ class Server::AllocatingRequestMatcherRegistered
 
   ArenaPromise<absl::StatusOr<MatchResult>> MatchRequest(
       size_t /*start_request_queue_index*/) override {
-    const bool still_running = server()->ShutdownRefOnRequest();
-    auto cleanup_ref =
-        absl::MakeCleanup([this] { server()->ShutdownUnrefOnRequest(); });
-    if (still_running) {
-      RegisteredCallAllocation call_info = allocator_();
-      GPR_ASSERT(server()->ValidateServerRequest(
-                     cq(), call_info.tag, call_info.optional_payload,
-                     registered_method_) == GRPC_CALL_OK);
-      RequestedCall* rc =
-          new RequestedCall(call_info.tag, call_info.cq, call_info.call,
-                            call_info.initial_metadata, registered_method_,
-                            call_info.deadline, call_info.optional_payload);
-      return Immediate(MatchResult{cq_idx(), rc});
-    } else {
-      return Immediate(absl::InternalError("Server shutdown"));
-    }
+    RegisteredCallAllocation call_info = allocator_();
+    GPR_ASSERT(server()->ValidateServerRequest(
+                   cq(), call_info.tag, call_info.optional_payload,
+                   registered_method_) == GRPC_CALL_OK);
+    RequestedCall* rc = new RequestedCall(
+        call_info.tag, call_info.cq, call_info.call, call_info.initial_metadata,
+        registered_method_, call_info.deadline, call_info.optional_payload);
+    return Immediate(MatchResult(server(), cq_idx(), rc));
   }
 
  private:
@@ -670,7 +687,9 @@ RefCountedPtr<channelz::ServerNode> CreateChannelzNode(
 }  // namespace
 
 Server::Server(const ChannelArgs& args)
-    : channel_args_(args), channelz_node_(CreateChannelzNode(args)) {}
+    : channel_args_(args),
+      channelz_node_(CreateChannelzNode(args)),
+      server_call_tracer_factory_(ServerCallTracerFactory::Get(args)) {}
 
 Server::~Server() {
   // Remove the cq pollsets from the config_fetcher.
@@ -923,7 +942,6 @@ void DonePublishedShutdown(void* /*done_arg*/, grpc_cq_completion* storage) {
 //       connection is NOT closed until the server is done with all those calls.
 //    -- Once there are no more calls in progress, the channel is closed.
 void Server::ShutdownAndNotify(grpc_completion_queue* cq, void* tag) {
-  Notification* await_requests = nullptr;
   ChannelBroadcaster broadcaster;
   {
     // Wait for startup to be finished.  Locks mu_global.
@@ -949,12 +967,7 @@ void Server::ShutdownAndNotify(grpc_completion_queue* cq, void* tag) {
       MutexLock lock(&mu_call_);
       KillPendingWorkLocked(GRPC_ERROR_CREATE("Server Shutdown"));
     }
-    await_requests = ShutdownUnrefOnShutdownCall();
-  }
-  // We expect no new requests but there can still be requests in-flight.
-  // Wait for them to complete before proceeding.
-  if (await_requests != nullptr) {
-    await_requests->WaitForNotification();
+    ShutdownUnrefOnShutdownCall();
   }
   StopListening();
   broadcaster.BroadcastShutdown(/*send_goaway=*/true, absl::OkStatus());
@@ -1190,6 +1203,10 @@ void Server::ChannelData::InitTransport(RefCountedPtr<Server> server,
   grpc_transport_op* op = grpc_make_transport_op(nullptr);
   op->set_accept_stream = true;
   op->set_accept_stream_fn = AcceptStream;
+  if (IsRegisteredMethodLookupInTransportEnabled()) {
+    op->set_registered_method_matcher_fn = SetRegisteredMethodOnMetadata;
+  }
+  // op->set_registered_method_matcher_fn = Registered
   op->set_accept_stream_user_data = this;
   op->start_connectivity_watch = MakeOrphanable<ConnectivityWatcher>(this);
   if (server_->ShutdownCalled()) {
@@ -1226,6 +1243,28 @@ Server::ChannelRegisteredMethod* Server::ChannelData::GetRegisteredMethod(
   return nullptr;
 }
 
+void Server::ChannelData::SetRegisteredMethodOnMetadata(
+    void* arg, ServerMetadata* metadata) {
+  auto* chand = static_cast<Server::ChannelData*>(arg);
+  auto* authority = metadata->get_pointer(HttpAuthorityMetadata());
+  if (authority == nullptr) {
+    authority = metadata->get_pointer(HostMetadata());
+    if (authority == nullptr) {
+      // Authority not being set is an RPC error.
+      return;
+    }
+  }
+  auto* path = metadata->get_pointer(HttpPathMetadata());
+  if (path == nullptr) {
+    // Path not being set would result in an RPC error.
+    return;
+  }
+  ChannelRegisteredMethod* method =
+      chand->GetRegisteredMethod(authority->c_slice(), path->c_slice());
+  // insert in metadata
+  metadata->Set(GrpcRegisteredMethod(), method);
+}
+
 void Server::ChannelData::AcceptStream(void* arg, grpc_transport* /*transport*/,
                                        const void* transport_server_data) {
   auto* chand = static_cast<Server::ChannelData*>(arg);
@@ -1257,17 +1296,24 @@ void Server::ChannelData::AcceptStream(void* arg, grpc_transport* /*transport*/,
   }
 }
 
+namespace {
+auto CancelledDueToServerShutdown() {
+  return [] {
+    return ServerMetadataFromStatus(absl::CancelledError("Server shutdown"));
+  };
+}
+}  // namespace
+
 ArenaPromise<ServerMetadataHandle> Server::ChannelData::MakeCallPromise(
     grpc_channel_element* elem, CallArgs call_args, NextPromiseFactory) {
   auto* chand = static_cast<Server::ChannelData*>(elem->channel_data);
   auto* server = chand->server_.get();
-  if (server->ShutdownCalled()) {
-    return [] {
-      return ServerMetadataFromStatus(absl::InternalError("Server shutdown"));
-    };
-  }
   absl::optional<Slice> path =
       call_args.client_initial_metadata->Take(HttpPathMetadata());
+  if (server->ShutdownCalled()) return CancelledDueToServerShutdown();
+  auto cleanup_ref =
+      absl::MakeCleanup([server] { server->ShutdownUnrefOnRequest(); });
+  if (!server->ShutdownRefOnRequest()) return CancelledDueToServerShutdown();
   if (!path.has_value()) {
     return [] {
       return ServerMetadataFromStatus(
@@ -1282,12 +1328,17 @@ ArenaPromise<ServerMetadataHandle> Server::ChannelData::MakeCallPromise(
           absl::InternalError("Missing :authority header"));
     };
   }
-  // TODO(ctiller): deadline handling
-  Timestamp deadline = Timestamp::InfFuture();
+  Timestamp deadline = GetContext<CallContext>()->deadline();
   // Find request matcher.
   RequestMatcherInterface* matcher;
-  ChannelRegisteredMethod* rm =
-      chand->GetRegisteredMethod(host_ptr->c_slice(), path->c_slice());
+  ChannelRegisteredMethod* rm = nullptr;
+  if (IsRegisteredMethodLookupInTransportEnabled()) {
+    rm = static_cast<ChannelRegisteredMethod*>(
+        call_args.client_initial_metadata->get(GrpcRegisteredMethod())
+            .value_or(nullptr));
+  } else {
+    rm = chand->GetRegisteredMethod(host_ptr->c_slice(), path->c_slice());
+  }
   ArenaPromise<absl::StatusOr<NextResult<MessageHandle>>>
       maybe_read_first_message([] { return NextResult<MessageHandle>(); });
   if (rm != nullptr) {
@@ -1307,22 +1358,36 @@ ArenaPromise<ServerMetadataHandle> Server::ChannelData::MakeCallPromise(
     matcher = server->unregistered_request_matcher_.get();
   }
   return TrySeq(
-      TryJoin(matcher->MatchRequest(chand->cq_idx()),
-              std::move(maybe_read_first_message)),
-      [path = std::move(*path), host = std::move(*host_ptr), deadline, server,
-       call_args = std::move(call_args)](
-          std::tuple<RequestMatcherInterface::MatchResult,
-                     NextResult<MessageHandle>>
-              match_result_and_payload) mutable {
-        auto& mr = std::get<0>(match_result_and_payload);
-        auto& payload = std::get<1>(match_result_and_payload);
-        auto* rc = mr.requested_call;
-        auto* cq_for_new_request = server->cqs_[mr.cq_idx];
+      std::move(maybe_read_first_message),
+      [cleanup_ref = std::move(cleanup_ref), matcher,
+       chand](NextResult<MessageHandle> payload) mutable {
+        return Map(
+            [cleanup_ref = std::move(cleanup_ref),
+             mr = matcher->MatchRequest(chand->cq_idx())]() mutable {
+              return mr();
+            },
+            [payload = std::move(payload)](
+                absl::StatusOr<RequestMatcherInterface::MatchResult> mr) mutable
+            -> absl::StatusOr<std::pair<RequestMatcherInterface::MatchResult,
+                                        NextResult<MessageHandle>>> {
+              if (!mr.ok()) return mr.status();
+              return std::make_pair(std::move(*mr), std::move(payload));
+            });
+      },
+      [host_ptr, path = std::move(path), deadline,
+       call_args =
+           std::move(call_args)](std::pair<RequestMatcherInterface::MatchResult,
+                                           NextResult<MessageHandle>>
+                                     r) mutable {
+        auto& mr = r.first;
+        auto& payload = r.second;
+        auto* rc = mr.TakeCall();
+        auto* cq_for_new_request = mr.cq();
         switch (rc->type) {
           case RequestedCall::Type::BATCH_CALL:
             GPR_ASSERT(!payload.has_value());
-            rc->data.batch.details->host = CSliceRef(host.c_slice());
-            rc->data.batch.details->method = CSliceRef(path.c_slice());
+            rc->data.batch.details->host = CSliceRef(host_ptr->c_slice());
+            rc->data.batch.details->method = CSliceRef(path->c_slice());
             rc->data.batch.details->deadline =
                 deadline.as_timespec(GPR_CLOCK_MONOTONIC);
             break;
@@ -1532,8 +1597,14 @@ void Server::CallData::StartNewRpc(grpc_call_element* elem) {
   grpc_server_register_method_payload_handling payload_handling =
       GRPC_SRM_PAYLOAD_NONE;
   if (path_.has_value() && host_.has_value()) {
-    ChannelRegisteredMethod* rm =
-        chand->GetRegisteredMethod(host_->c_slice(), path_->c_slice());
+    ChannelRegisteredMethod* rm;
+    if (IsRegisteredMethodLookupInTransportEnabled()) {
+      rm = static_cast<ChannelRegisteredMethod*>(
+          recv_initial_metadata_->get(GrpcRegisteredMethod())
+              .value_or(nullptr));
+    } else {
+      rm = chand->GetRegisteredMethod(host_->c_slice(), path_->c_slice());
+    }
     if (rm != nullptr) {
       matcher_ = rm->server_registered_method->matcher.get();
       payload_handling = rm->server_registered_method->payload_handling;