grpc 1.45.0 → 1.53.0

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

@@ -18,41 +18,65 @@
 
 #include "src/core/lib/surface/server.h"
 
-#include <limits.h>
+#include <inttypes.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include <algorithm>
 #include <atomic>
-#include <iterator>
+#include <initializer_list>
 #include <list>
+#include <new>
 #include <queue>
+#include <tuple>
+#include <type_traits>
 #include <utility>
 #include <vector>
 
-#include "absl/memory/memory.h"
+#include "absl/cleanup/cleanup.h"
+#include "absl/status/status.h"
 #include "absl/types/optional.h"
+#include "absl/types/variant.h"
 
-#include <grpc/support/alloc.h>
+#include <grpc/byte_buffer.h>
+#include <grpc/impl/connectivity_state.h>
+#include <grpc/status.h>
 #include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
+#include <grpc/support/time.h>
 
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_args_preconditioning.h"
+#include "src/core/lib/channel/channel_trace.h"
 #include "src/core/lib/channel/channelz.h"
-#include "src/core/lib/channel/connected_channel.h"
-#include "src/core/lib/debug/stats.h"
-#include "src/core/lib/gpr/spinlock.h"
-#include "src/core/lib/gpr/string.h"
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/experiments/experiments.h"
+#include "src/core/lib/gpr/useful.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/gprpp/mpscq.h"
-#include "src/core/lib/iomgr/executor.h"
-#include "src/core/lib/iomgr/iomgr.h"
-#include "src/core/lib/resource_quota/api.h"
+#include "src/core/lib/gprpp/status_helper.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#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/try_seq.h"
+#include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/call.h"
 #include "src/core/lib/surface/channel.h"
+#include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/surface/completion_queue.h"
-#include "src/core/lib/surface/init.h"
+#include "src/core/lib/transport/connectivity_state.h"
+#include "src/core/lib/transport/error_utils.h"
 
 namespace grpc_core {
 
@@ -73,7 +97,6 @@ struct Server::RequestedCall {
         cq_bound_to_call(call_cq),
         call(call_arg),
         initial_metadata(initial_md) {
-    details->reserved = nullptr;
     data.batch.details = details;
   }
 
@@ -172,6 +195,20 @@ class Server::RequestMatcherInterface {
   virtual void RequestCallWithPossiblePublish(size_t request_queue_index,
                                               RequestedCall* call) = 0;
 
+  struct MatchResult {
+    size_t cq_idx;
+    RequestedCall* requested_call;
+  };
+
+  // This function is invoked on an incoming promise based RPC.
+  // The RequestMatcher will try to match it against an application-requested
+  // RPC if possible or will place it in the pending queue otherwise. To enable
+  // some measure of fairness between server CQs, the match is done starting at
+  // the start_request_queue_index parameter in a cyclic order rather than
+  // always starting at 0.
+  virtual ArenaPromise<absl::StatusOr<MatchResult>> MatchRequest(
+      size_t start_request_queue_index) = 0;
+
   // This function is invoked on an incoming RPC, represented by the calld
   // object. The RequestMatcher will try to match it against an
   // application-requested RPC if possible or will place it in the pending queue
@@ -203,9 +240,15 @@ class Server::RealRequestMatcher : public RequestMatcherInterface {
 
   void ZombifyPending() override {
     while (!pending_.empty()) {
-      CallData* calld = pending_.front();
-      calld->SetState(CallData::CallState::ZOMBIED);
-      calld->KillZombie();
+      Match(
+          pending_.front(),
+          [](CallData* calld) {
+            calld->SetState(CallData::CallState::ZOMBIED);
+            calld->KillZombie();
+          },
+          [](const std::shared_ptr<ActivityWaiter>& w) {
+            w->Finish(absl::InternalError("Server closed"));
+          });
       pending_.pop();
     }
   }
@@ -215,10 +258,9 @@ class Server::RealRequestMatcher : public RequestMatcherInterface {
       RequestedCall* rc;
       while ((rc = reinterpret_cast<RequestedCall*>(
                   requests_per_cq_[i].Pop())) != nullptr) {
-        server_->FailCall(i, rc, GRPC_ERROR_REF(error));
+        server_->FailCall(i, rc, error);
       }
     }
-    GRPC_ERROR_UNREF(error);
   }
 
   size_t request_queue_count() const override {
@@ -228,21 +270,21 @@ class Server::RealRequestMatcher : public RequestMatcherInterface {
   void RequestCallWithPossiblePublish(size_t request_queue_index,
                                       RequestedCall* call) override {
     if (requests_per_cq_[request_queue_index].Push(&call->mpscq_node)) {
-      /* this was the first queued request: we need to lock and start
-         matching calls */
-      struct PendingCall {
+      // this was the first queued request: we need to lock and start
+      // matching calls
+      struct NextPendingCall {
         RequestedCall* rc = nullptr;
-        CallData* calld;
+        PendingCall pending;
       };
       auto pop_next_pending = [this, request_queue_index] {
-        PendingCall pending_call;
+        NextPendingCall pending_call;
         {
           MutexLock lock(&server_->mu_call_);
           if (!pending_.empty()) {
             pending_call.rc = reinterpret_cast<RequestedCall*>(
                 requests_per_cq_[request_queue_index].Pop());
             if (pending_call.rc != nullptr) {
-              pending_call.calld = pending_.front();
+              pending_call.pending = std::move(pending_.front());
               pending_.pop();
             }
           }
@@ -250,14 +292,20 @@ class Server::RealRequestMatcher : public RequestMatcherInterface {
         return pending_call;
       };
       while (true) {
-        PendingCall next_pending = pop_next_pending();
+        NextPendingCall next_pending = pop_next_pending();
         if (next_pending.rc == nullptr) break;
-        if (!next_pending.calld->MaybeActivate()) {
-          // Zombied Call
-          next_pending.calld->KillZombie();
-        } else {
-          next_pending.calld->Publish(request_queue_index, next_pending.rc);
-        }
+        auto mr = MatchResult{request_queue_index, next_pending.rc};
+        Match(
+            next_pending.pending,
+            [mr](CallData* calld) {
+              if (!calld->MaybeActivate()) {
+                // Zombied Call
+                calld->KillZombie();
+              } else {
+                calld->Publish(mr.cq_idx, mr.requested_call);
+              }
+            },
+            [mr](const std::shared_ptr<ActivityWaiter>& w) { w->Finish(mr); });
       }
     }
   }
@@ -269,14 +317,12 @@ class Server::RealRequestMatcher : public RequestMatcherInterface {
       RequestedCall* rc =
           reinterpret_cast<RequestedCall*>(requests_per_cq_[cq_idx].TryPop());
       if (rc != nullptr) {
-        GRPC_STATS_INC_SERVER_CQS_CHECKED(i);
         calld->SetState(CallData::CallState::ACTIVATED);
         calld->Publish(cq_idx, rc);
         return;
       }
     }
     // No cq to take the request found; queue it on the slow list.
-    GRPC_STATS_INC_SERVER_SLOWPATH_REQUESTS_QUEUED();
     // We need to ensure that all the queues are empty.  We do this under
     // the server mu_call_ lock to ensure that if something is added to
     // an empty request queue, it will block until the call is actually
@@ -300,16 +346,70 @@ class Server::RealRequestMatcher : public RequestMatcherInterface {
         return;
       }
     }
-    GRPC_STATS_INC_SERVER_CQS_CHECKED(loop_count + requests_per_cq_.size());
     calld->SetState(CallData::CallState::ACTIVATED);
     calld->Publish(cq_idx, rc);
   }
 
+  ArenaPromise<absl::StatusOr<MatchResult>> MatchRequest(
+      size_t start_request_queue_index) override {
+    for (size_t i = 0; i < requests_per_cq_.size(); i++) {
+      size_t cq_idx = (start_request_queue_index + i) % requests_per_cq_.size();
+      RequestedCall* rc =
+          reinterpret_cast<RequestedCall*>(requests_per_cq_[cq_idx].TryPop());
+      if (rc != nullptr) {
+        return Immediate(MatchResult{cq_idx, rc});
+      }
+    }
+    // No cq to take the request found; queue it on the slow list.
+    // We need to ensure that all the queues are empty.  We do this under
+    // the server mu_call_ lock to ensure that if something is added to
+    // an empty request queue, it will block until the call is actually
+    // added to the pending list.
+    RequestedCall* rc = nullptr;
+    size_t cq_idx = 0;
+    size_t loop_count;
+    {
+      MutexLock lock(&server_->mu_call_);
+      for (loop_count = 0; loop_count < requests_per_cq_.size(); loop_count++) {
+        cq_idx =
+            (start_request_queue_index + loop_count) % requests_per_cq_.size();
+        rc = reinterpret_cast<RequestedCall*>(requests_per_cq_[cq_idx].Pop());
+        if (rc != nullptr) {
+          break;
+        }
+      }
+      if (rc == nullptr) {
+        auto w = std::make_shared<ActivityWaiter>(
+            Activity::current()->MakeOwningWaker());
+        pending_.push(w);
+        return [w]() -> Poll<absl::StatusOr<MatchResult>> {
+          std::unique_ptr<absl::StatusOr<MatchResult>> r(
+              w->result.exchange(nullptr, std::memory_order_acq_rel));
+          if (r == nullptr) return Pending{};
+          return std::move(*r);
+        };
+      }
+    }
+    return Immediate(MatchResult{cq_idx, rc});
+  }
+
   Server* server() const override { return server_; }
 
  private:
   Server* const server_;
-  std::queue<CallData*> pending_;
+  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)),
+                   std::memory_order_release);
+      waker.Wakeup();
+    }
+    Waker waker;
+    std::atomic<absl::StatusOr<MatchResult>*> result{nullptr};
+  };
+  using PendingCall = absl::variant<CallData*, std::shared_ptr<ActivityWaiter>>;
+  std::queue<PendingCall> pending_;
   std::vector<LockedMultiProducerSingleConsumerQueue> requests_per_cq_;
 };
 
@@ -335,15 +435,13 @@ class Server::AllocatingRequestMatcherBase : public RequestMatcherInterface {
 
   void ZombifyPending() override {}
 
-  void KillRequests(grpc_error_handle error) override {
-    GRPC_ERROR_UNREF(error);
-  }
+  void KillRequests(grpc_error_handle /*error*/) override {}
 
   size_t request_queue_count() const override { return 0; }
 
   void RequestCallWithPossiblePublish(size_t /*request_queue_index*/,
                                       RequestedCall* /*call*/) final {
-    GPR_ASSERT(false);
+    Crash("unreachable");
   }
 
   Server* server() const override { return server_; }
@@ -372,7 +470,10 @@ class Server::AllocatingRequestMatcherBatch
 
   void MatchOrQueue(size_t /*start_request_queue_index*/,
                     CallData* calld) override {
-    if (server()->ShutdownRefOnRequest()) {
+    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,
@@ -385,7 +486,25 @@ class Server::AllocatingRequestMatcherBatch
     } else {
       calld->FailCallCreation();
     }
-    server()->ShutdownUnrefOnRequest();
+  }
+
+  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"));
+    }
   }
 
  private:
@@ -405,6 +524,8 @@ class Server::AllocatingRequestMatcherRegistered
 
   void MatchOrQueue(size_t /*start_request_queue_index*/,
                     CallData* calld) override {
+    auto cleanup_ref =
+        absl::MakeCleanup([this] { server()->ShutdownUnrefOnRequest(); });
     if (server()->ShutdownRefOnRequest()) {
       RegisteredCallAllocation call_info = allocator_();
       GPR_ASSERT(server()->ValidateServerRequest(
@@ -419,7 +540,26 @@ class Server::AllocatingRequestMatcherRegistered
     } else {
       calld->FailCallCreation();
     }
-    server()->ShutdownUnrefOnRequest();
+  }
+
+  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"));
+    }
   }
 
  private:
@@ -439,19 +579,17 @@ class ChannelBroadcaster {
   // when the actual setup and shutdown broadcast take place.
 
   // Copies over the channels from the locked server.
-  void FillChannelsLocked(std::vector<grpc_channel*> channels) {
+  void FillChannelsLocked(std::vector<RefCountedPtr<Channel>> channels) {
     GPR_DEBUG_ASSERT(channels_.empty());
     channels_ = std::move(channels);
   }
 
   // Broadcasts a shutdown on each channel.
   void BroadcastShutdown(bool send_goaway, grpc_error_handle force_disconnect) {
-    for (grpc_channel* channel : channels_) {
-      SendShutdown(channel, send_goaway, GRPC_ERROR_REF(force_disconnect));
-      GRPC_CHANNEL_INTERNAL_UNREF(channel, "broadcast");
+    for (const RefCountedPtr<Channel>& channel : channels_) {
+      SendShutdown(channel->c_ptr(), send_goaway, force_disconnect);
     }
     channels_.clear();  // just for safety against double broadcast
-    GRPC_ERROR_UNREF(force_disconnect);
   }
 
  private:
@@ -462,7 +600,7 @@ class ChannelBroadcaster {
 
   static void ShutdownCleanup(void* arg, grpc_error_handle /*error*/) {
     ShutdownCleanupArgs* a = static_cast<ShutdownCleanupArgs*>(arg);
-    grpc_slice_unref_internal(a->slice);
+    CSliceUnref(a->slice);
     delete a;
   }
 
@@ -475,11 +613,9 @@ class ChannelBroadcaster {
     grpc_channel_element* elem;
     op->goaway_error =
         send_goaway
-            ? grpc_error_set_int(
-                  GRPC_ERROR_CREATE_FROM_STATIC_STRING("Server shutdown"),
-                  GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_OK)
-            : GRPC_ERROR_NONE;
-    op->set_accept_stream = true;
+            ? grpc_error_set_int(GRPC_ERROR_CREATE("Server shutdown"),
+                                 StatusIntProperty::kRpcStatus, GRPC_STATUS_OK)
+            : absl::OkStatus();
     sc->slice = grpc_slice_from_copied_string("Server shutdown");
     op->disconnect_with_error = send_disconnect;
     elem =
@@ -487,7 +623,7 @@ class ChannelBroadcaster {
     elem->filter->start_transport_op(elem, op);
   }
 
-  std::vector<grpc_channel*> channels_;
+  std::vector<RefCountedPtr<Channel>> channels_;
 };
 
 }  // namespace
@@ -498,7 +634,7 @@ class ChannelBroadcaster {
 
 const grpc_channel_filter Server::kServerTopFilter = {
     Server::CallData::StartTransportStreamOpBatch,
-    nullptr,
+    Server::ChannelData::MakeCallPromise,
     grpc_channel_next_op,
     sizeof(Server::CallData),
     Server::CallData::InitCallElement,
@@ -506,6 +642,7 @@ const grpc_channel_filter Server::kServerTopFilter = {
     Server::CallData::DestroyCallElement,
     sizeof(Server::ChannelData),
     Server::ChannelData::InitChannelElement,
+    grpc_channel_stack_no_post_init,
     Server::ChannelData::DestroyChannelElement,
     grpc_channel_next_get_info,
     "server",
@@ -514,13 +651,13 @@ const grpc_channel_filter Server::kServerTopFilter = {
 namespace {
 
 RefCountedPtr<channelz::ServerNode> CreateChannelzNode(
-    const grpc_channel_args* args) {
+    const ChannelArgs& args) {
   RefCountedPtr<channelz::ServerNode> channelz_node;
-  if (grpc_channel_args_find_bool(args, GRPC_ARG_ENABLE_CHANNELZ,
-                                  GRPC_ENABLE_CHANNELZ_DEFAULT)) {
-    size_t channel_tracer_max_memory = grpc_channel_args_find_integer(
-        args, GRPC_ARG_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE,
-        {GRPC_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE_DEFAULT, 0, INT_MAX});
+  if (args.GetBool(GRPC_ARG_ENABLE_CHANNELZ)
+          .value_or(GRPC_ENABLE_CHANNELZ_DEFAULT)) {
+    size_t channel_tracer_max_memory = std::max(
+        0, args.GetInt(GRPC_ARG_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE)
+               .value_or(GRPC_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE_DEFAULT));
     channelz_node =
         MakeRefCounted<channelz::ServerNode>(channel_tracer_max_memory);
     channelz_node->AddTraceEvent(
@@ -532,12 +669,10 @@ RefCountedPtr<channelz::ServerNode> CreateChannelzNode(
 
 }  // namespace
 
-Server::Server(const grpc_channel_args* args)
-    : channel_args_(grpc_channel_args_copy(args)),
-      channelz_node_(CreateChannelzNode(args)) {}
+Server::Server(const ChannelArgs& args)
+    : channel_args_(args), channelz_node_(CreateChannelzNode(args)) {}
 
 Server::~Server() {
-  grpc_channel_args_destroy(channel_args_);
   // Remove the cq pollsets from the config_fetcher.
   if (started_ && config_fetcher_ != nullptr &&
       config_fetcher_->interested_parties() != nullptr) {
@@ -568,11 +703,11 @@ void Server::Start() {
     }
   }
   if (unregistered_request_matcher_ == nullptr) {
-    unregistered_request_matcher_ = absl::make_unique<RealRequestMatcher>(this);
+    unregistered_request_matcher_ = std::make_unique<RealRequestMatcher>(this);
   }
   for (std::unique_ptr<RegisteredMethod>& rm : registered_methods_) {
     if (rm->matcher == nullptr) {
-      rm->matcher = absl::make_unique<RealRequestMatcher>(this);
+      rm->matcher = std::make_unique<RealRequestMatcher>(this);
     }
   }
   {
@@ -599,18 +734,16 @@ void Server::Start() {
 
 grpc_error_handle Server::SetupTransport(
     grpc_transport* transport, grpc_pollset* accepting_pollset,
-    const grpc_channel_args* args,
+    const ChannelArgs& args,
     const RefCountedPtr<channelz::SocketNode>& socket_node) {
   // Create channel.
-  grpc_error_handle error = GRPC_ERROR_NONE;
-  grpc_channel* channel = grpc_channel_create_internal(
-      nullptr, args, GRPC_SERVER_CHANNEL, transport, &error);
-  if (channel == nullptr) {
-    return error;
+  absl::StatusOr<RefCountedPtr<Channel>> channel =
+      Channel::Create(nullptr, args, GRPC_SERVER_CHANNEL, transport);
+  if (!channel.ok()) {
+    return absl_status_to_grpc_error(channel.status());
   }
   ChannelData* chand = static_cast<ChannelData*>(
-      grpc_channel_stack_element(grpc_channel_get_channel_stack(channel), 0)
-          ->channel_data);
+      grpc_channel_stack_element((*channel)->channel_stack(), 0)->channel_data);
   // Set up CQs.
   size_t cq_idx;
   for (cq_idx = 0; cq_idx < cqs_.size(); cq_idx++) {
@@ -627,8 +760,9 @@ grpc_error_handle Server::SetupTransport(
     channelz_node_->AddChildSocket(socket_node);
   }
   // Initialize chand.
-  chand->InitTransport(Ref(), channel, cq_idx, transport, channelz_socket_uuid);
-  return GRPC_ERROR_NONE;
+  chand->InitTransport(Ref(), std::move(*channel), cq_idx, transport,
+                       channelz_socket_uuid);
+  return absl::OkStatus();
 }
 
 bool Server::HasOpenConnections() {
@@ -640,7 +774,7 @@ void Server::SetRegisteredMethodAllocator(
     grpc_completion_queue* cq, void* method_tag,
     std::function<RegisteredCallAllocation()> allocator) {
   RegisteredMethod* rm = static_cast<RegisteredMethod*>(method_tag);
-  rm->matcher = absl::make_unique<AllocatingRequestMatcherRegistered>(
+  rm->matcher = std::make_unique<AllocatingRequestMatcherRegistered>(
       this, cq, rm, std::move(allocator));
 }
 
@@ -648,8 +782,8 @@ void Server::SetBatchMethodAllocator(
     grpc_completion_queue* cq, std::function<BatchCallAllocation()> allocator) {
   GPR_DEBUG_ASSERT(unregistered_request_matcher_ == nullptr);
   unregistered_request_matcher_ =
-      absl::make_unique<AllocatingRequestMatcherBatch>(this, cq,
-                                                       std::move(allocator));
+      std::make_unique<AllocatingRequestMatcherBatch>(this, cq,
+                                                      std::move(allocator));
 }
 
 void Server::RegisterCompletionQueue(grpc_completion_queue* cq) {
@@ -685,12 +819,12 @@ Server::RegisteredMethod* Server::RegisterMethod(
       return nullptr;
     }
   }
-  if ((flags & ~GRPC_INITIAL_METADATA_USED_MASK) != 0) {
+  if (flags != 0) {
     gpr_log(GPR_ERROR, "grpc_server_register_method invalid flags 0x%08x",
             flags);
     return nullptr;
   }
-  registered_methods_.emplace_back(absl::make_unique<RegisteredMethod>(
+  registered_methods_.emplace_back(std::make_unique<RegisteredMethod>(
       method, host, payload_handling, flags));
   return registered_methods_.back().get();
 }
@@ -703,7 +837,7 @@ void Server::FailCall(size_t cq_idx, RequestedCall* rc,
                       grpc_error_handle error) {
   *rc->call = nullptr;
   rc->initial_metadata->count = 0;
-  GPR_ASSERT(error != GRPC_ERROR_NONE);
+  GPR_ASSERT(!error.ok());
   grpc_cq_end_op(cqs_[cq_idx], rc->tag, error, DoneRequestEvent, rc,
                  &rc->completion);
 }
@@ -716,8 +850,7 @@ void Server::MaybeFinishShutdown() {
   }
   {
     MutexLock lock(&mu_call_);
-    KillPendingWorkLocked(
-        GRPC_ERROR_CREATE_FROM_STATIC_STRING("Server Shutdown"));
+    KillPendingWorkLocked(GRPC_ERROR_CREATE("Server Shutdown"));
   }
   if (!channels_.empty() || listeners_destroyed_ < listeners_.size()) {
     if (gpr_time_cmp(gpr_time_sub(gpr_now(GPR_CLOCK_REALTIME),
@@ -735,29 +868,27 @@ void Server::MaybeFinishShutdown() {
   shutdown_published_ = true;
   for (auto& shutdown_tag : shutdown_tags_) {
     Ref().release();
-    grpc_cq_end_op(shutdown_tag.cq, shutdown_tag.tag, GRPC_ERROR_NONE,
+    grpc_cq_end_op(shutdown_tag.cq, shutdown_tag.tag, absl::OkStatus(),
                    DoneShutdownEvent, this, &shutdown_tag.completion);
   }
 }
 
 void Server::KillPendingWorkLocked(grpc_error_handle error) {
   if (started_) {
-    unregistered_request_matcher_->KillRequests(GRPC_ERROR_REF(error));
+    unregistered_request_matcher_->KillRequests(error);
     unregistered_request_matcher_->ZombifyPending();
     for (std::unique_ptr<RegisteredMethod>& rm : registered_methods_) {
-      rm->matcher->KillRequests(GRPC_ERROR_REF(error));
+      rm->matcher->KillRequests(error);
       rm->matcher->ZombifyPending();
     }
   }
-  GRPC_ERROR_UNREF(error);
 }
 
-std::vector<grpc_channel*> Server::GetChannelsLocked() const {
-  std::vector<grpc_channel*> channels;
+std::vector<RefCountedPtr<Channel>> Server::GetChannelsLocked() const {
+  std::vector<RefCountedPtr<Channel>> channels;
   channels.reserve(channels_.size());
   for (const ChannelData* chand : channels_) {
-    channels.push_back(chand->channel());
-    GRPC_CHANNEL_INTERNAL_REF(chand->channel(), "broadcast");
+    channels.push_back(chand->channel()->Ref());
   }
   return channels;
 }
@@ -792,7 +923,7 @@ 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) {
-  absl::Notification* await_requests = nullptr;
+  Notification* await_requests = nullptr;
   ChannelBroadcaster broadcaster;
   {
     // Wait for startup to be finished.  Locks mu_global.
@@ -803,7 +934,7 @@ void Server::ShutdownAndNotify(grpc_completion_queue* cq, void* tag) {
     // Stay locked, and gather up some stuff to do.
     GPR_ASSERT(grpc_cq_begin_op(cq, tag));
     if (shutdown_published_) {
-      grpc_cq_end_op(cq, tag, GRPC_ERROR_NONE, DonePublishedShutdown, nullptr,
+      grpc_cq_end_op(cq, tag, absl::OkStatus(), DonePublishedShutdown, nullptr,
                      new grpc_cq_completion);
       return;
     }
@@ -816,8 +947,7 @@ void Server::ShutdownAndNotify(grpc_completion_queue* cq, void* tag) {
     // Collect all unregistered then registered calls.
     {
       MutexLock lock(&mu_call_);
-      KillPendingWorkLocked(
-          GRPC_ERROR_CREATE_FROM_STATIC_STRING("Server Shutdown"));
+      KillPendingWorkLocked(GRPC_ERROR_CREATE("Server Shutdown"));
     }
     await_requests = ShutdownUnrefOnShutdownCall();
   }
@@ -826,8 +956,13 @@ void Server::ShutdownAndNotify(grpc_completion_queue* cq, void* tag) {
   if (await_requests != nullptr) {
     await_requests->WaitForNotification();
   }
-  // Shutdown listeners.
+  StopListening();
+  broadcaster.BroadcastShutdown(/*send_goaway=*/true, absl::OkStatus());
+}
+
+void Server::StopListening() {
   for (auto& listener : listeners_) {
+    if (listener.listener == nullptr) continue;
     channelz::ListenSocketNode* channelz_listen_socket_node =
         listener.listener->channelz_listen_socket_node();
     if (channelz_node_ != nullptr && channelz_listen_socket_node != nullptr) {
@@ -839,7 +974,6 @@ void Server::ShutdownAndNotify(grpc_completion_queue* cq, void* tag) {
     listener.listener->SetOnDestroyDone(&listener.destroy_done);
     listener.listener.reset();
   }
-  broadcaster.BroadcastShutdown(/*send_goaway=*/true, GRPC_ERROR_NONE);
 }
 
 void Server::CancelAllCalls() {
@@ -849,8 +983,16 @@ void Server::CancelAllCalls() {
     broadcaster.FillChannelsLocked(GetChannelsLocked());
   }
   broadcaster.BroadcastShutdown(
-      /*send_goaway=*/false,
-      GRPC_ERROR_CREATE_FROM_STATIC_STRING("Cancelling all calls"));
+      /*send_goaway=*/false, GRPC_ERROR_CREATE("Cancelling all calls"));
+}
+
+void Server::SendGoaways() {
+  ChannelBroadcaster broadcaster;
+  {
+    MutexLock lock(&mu_global_);
+    broadcaster.FillChannelsLocked(GetChannelsLocked());
+  }
+  broadcaster.BroadcastShutdown(/*send_goaway=*/true, absl::OkStatus());
 }
 
 void Server::Orphan() {
@@ -899,8 +1041,7 @@ grpc_call_error Server::ValidateServerRequestAndCq(
 
 grpc_call_error Server::QueueRequestedCall(size_t cq_idx, RequestedCall* rc) {
   if (ShutdownCalled()) {
-    FailCall(cq_idx, rc,
-             GRPC_ERROR_CREATE_FROM_STATIC_STRING("Server Shutdown"));
+    FailCall(cq_idx, rc, GRPC_ERROR_CREATE("Server Shutdown"));
     return GRPC_CALL_OK;
   }
   RequestMatcherInterface* rm;
@@ -957,13 +1098,8 @@ grpc_call_error Server::RequestRegisteredCall(
 class Server::ChannelData::ConnectivityWatcher
     : public AsyncConnectivityStateWatcherInterface {
  public:
-  explicit ConnectivityWatcher(ChannelData* chand) : chand_(chand) {
-    GRPC_CHANNEL_INTERNAL_REF(chand_->channel_, "connectivity");
-  }
-
-  ~ConnectivityWatcher() override {
-    GRPC_CHANNEL_INTERNAL_UNREF(chand_->channel_, "connectivity");
-  }
+  explicit ConnectivityWatcher(ChannelData* chand)
+      : chand_(chand), channel_(chand_->channel_->Ref()) {}
 
  private:
   void OnConnectivityStateChange(grpc_connectivity_state new_state,
@@ -975,7 +1111,8 @@ class Server::ChannelData::ConnectivityWatcher
     chand_->Destroy();
   }
 
-  ChannelData* chand_;
+  ChannelData* const chand_;
+  const RefCountedPtr<Channel> channel_;
 };
 
 //
@@ -1000,7 +1137,8 @@ Server::ChannelData::~ChannelData() {
 }
 
 void Server::ChannelData::InitTransport(RefCountedPtr<Server> server,
-                                        grpc_channel* channel, size_t cq_idx,
+                                        RefCountedPtr<Channel> channel,
+                                        size_t cq_idx,
                                         grpc_transport* transport,
                                         intptr_t channelz_socket_uuid) {
   server_ = std::move(server);
@@ -1014,7 +1152,7 @@ void Server::ChannelData::InitTransport(RefCountedPtr<Server> server,
     uint32_t max_probes = 0;
     size_t slots = 2 * num_registered_methods;
     registered_methods_ =
-        absl::make_unique<std::vector<ChannelRegisteredMethod>>(slots);
+        std::make_unique<std::vector<ChannelRegisteredMethod>>(slots);
     for (std::unique_ptr<RegisteredMethod>& rm : server_->registered_methods_) {
       Slice host;
       Slice method = Slice::FromExternalString(rm->method);
@@ -1055,19 +1193,17 @@ void Server::ChannelData::InitTransport(RefCountedPtr<Server> server,
   op->set_accept_stream_user_data = this;
   op->start_connectivity_watch = MakeOrphanable<ConnectivityWatcher>(this);
   if (server_->ShutdownCalled()) {
-    op->disconnect_with_error =
-        GRPC_ERROR_CREATE_FROM_STATIC_STRING("Server shutdown");
+    op->disconnect_with_error = GRPC_ERROR_CREATE("Server shutdown");
   }
   grpc_transport_perform_op(transport, op);
 }
 
 Server::ChannelRegisteredMethod* Server::ChannelData::GetRegisteredMethod(
-    const grpc_slice& host, const grpc_slice& path, bool is_idempotent) {
+    const grpc_slice& host, const grpc_slice& path) {
   if (registered_methods_ == nullptr) return nullptr;
-  /* TODO(ctiller): unify these two searches */
-  /* check for an exact match with host */
-  uint32_t hash =
-      MixHash32(grpc_slice_hash_internal(host), grpc_slice_hash_internal(path));
+  // TODO(ctiller): unify these two searches
+  // check for an exact match with host
+  uint32_t hash = MixHash32(grpc_slice_hash(host), grpc_slice_hash(path));
   for (size_t i = 0; i <= registered_method_max_probes_; i++) {
     ChannelRegisteredMethod* rm =
         &(*registered_methods_)[(hash + i) % registered_methods_->size()];
@@ -1075,24 +1211,16 @@ Server::ChannelRegisteredMethod* Server::ChannelData::GetRegisteredMethod(
     if (!rm->has_host) continue;
     if (rm->host != host) continue;
     if (rm->method != path) continue;
-    if ((rm->flags & GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST) &&
-        !is_idempotent) {
-      continue;
-    }
     return rm;
   }
-  /* check for a wildcard method definition (no host set) */
-  hash = MixHash32(0, grpc_slice_hash_internal(path));
+  // check for a wildcard method definition (no host set)
+  hash = MixHash32(0, grpc_slice_hash(path));
   for (size_t i = 0; i <= registered_method_max_probes_; i++) {
     ChannelRegisteredMethod* rm =
         &(*registered_methods_)[(hash + i) % registered_methods_->size()];
     if (rm->server_registered_method == nullptr) break;
     if (rm->has_host) continue;
     if (rm->method != path) continue;
-    if ((rm->flags & GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST) &&
-        !is_idempotent) {
-      continue;
-    }
     return rm;
   }
   return nullptr;
@@ -1101,7 +1229,7 @@ Server::ChannelRegisteredMethod* Server::ChannelData::GetRegisteredMethod(
 void Server::ChannelData::AcceptStream(void* arg, grpc_transport* /*transport*/,
                                        const void* transport_server_data) {
   auto* chand = static_cast<Server::ChannelData*>(arg);
-  /* create a call */
+  // create a call
   grpc_call_create_args args;
   args.channel = chand->channel_;
   args.server = chand->server_.get();
@@ -1113,23 +1241,129 @@ void Server::ChannelData::AcceptStream(void* arg, grpc_transport* /*transport*/,
   args.send_deadline = Timestamp::InfFuture();
   grpc_call* call;
   grpc_error_handle error = grpc_call_create(&args, &call);
-  grpc_call_element* elem =
-      grpc_call_stack_element(grpc_call_get_call_stack(call), 0);
-  auto* calld = static_cast<Server::CallData*>(elem->call_data);
-  if (error != GRPC_ERROR_NONE) {
-    GRPC_ERROR_UNREF(error);
-    calld->FailCallCreation();
+  grpc_call_stack* call_stack = grpc_call_get_call_stack(call);
+  if (call_stack == nullptr) {  // Promise based calls do not have a call stack
+    GPR_ASSERT(error.ok());
+    GPR_ASSERT(IsPromiseBasedServerCallEnabled());
     return;
+  } else {
+    grpc_call_element* elem = grpc_call_stack_element(call_stack, 0);
+    auto* calld = static_cast<Server::CallData*>(elem->call_data);
+    if (!error.ok()) {
+      calld->FailCallCreation();
+      return;
+    }
+    calld->Start(elem);
   }
-  calld->Start(elem);
+}
+
+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 (!path.has_value()) {
+    return [] {
+      return ServerMetadataFromStatus(
+          absl::InternalError("Missing :path header"));
+    };
+  }
+  auto host_ptr =
+      call_args.client_initial_metadata->get_pointer(HttpAuthorityMetadata());
+  if (host_ptr == nullptr) {
+    return [] {
+      return ServerMetadataFromStatus(
+          absl::InternalError("Missing :authority header"));
+    };
+  }
+  // TODO(ctiller): deadline handling
+  Timestamp deadline = Timestamp::InfFuture();
+  // Find request matcher.
+  RequestMatcherInterface* matcher;
+  ChannelRegisteredMethod* 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) {
+    matcher = rm->server_registered_method->matcher.get();
+    switch (rm->server_registered_method->payload_handling) {
+      case GRPC_SRM_PAYLOAD_NONE:
+        break;
+      case GRPC_SRM_PAYLOAD_READ_INITIAL_BYTE_BUFFER:
+        maybe_read_first_message =
+            Map(call_args.client_to_server_messages->Next(),
+                [](NextResult<MessageHandle> msg)
+                    -> absl::StatusOr<NextResult<MessageHandle>> {
+                  return std::move(msg);
+                });
+    }
+  } else {
+    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];
+        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->deadline =
+                deadline.as_timespec(GPR_CLOCK_MONOTONIC);
+            break;
+          case RequestedCall::Type::REGISTERED_CALL:
+            *rc->data.registered.deadline =
+                deadline.as_timespec(GPR_CLOCK_MONOTONIC);
+            if (rc->data.registered.optional_payload != nullptr) {
+              if (payload.has_value()) {
+                auto* sb = payload.value()->payload()->c_slice_buffer();
+                *rc->data.registered.optional_payload =
+                    grpc_raw_byte_buffer_create(sb->slices, sb->count);
+              } else {
+                *rc->data.registered.optional_payload = nullptr;
+              }
+            }
+            break;
+          default:
+            GPR_UNREACHABLE_CODE(abort());
+        }
+        return GetContext<CallContext>()
+            ->server_call_context()
+            ->MakeTopOfServerCallPromise(
+                std::move(call_args), rc->cq_bound_to_call,
+                rc->initial_metadata,
+                [rc, cq_for_new_request](grpc_call* call) {
+                  *rc->call = call;
+                  grpc_cq_end_op(cq_for_new_request, rc->tag, absl::OkStatus(),
+                                 Server::DoneRequestEvent, rc, &rc->completion,
+                                 true);
+                });
+      });
 }
 
 void Server::ChannelData::FinishDestroy(void* arg,
                                         grpc_error_handle /*error*/) {
   auto* chand = static_cast<Server::ChannelData*>(arg);
   Server* server = chand->server_.get();
-  GRPC_CHANNEL_INTERNAL_UNREF(chand->channel_, "server");
+  auto* channel_stack = chand->channel_->channel_stack();
+  chand->channel_.reset();
   server->Unref();
+  GRPC_CHANNEL_STACK_UNREF(channel_stack, "Server::ChannelData::Destroy");
 }
 
 void Server::ChannelData::Destroy() {
@@ -1139,6 +1373,9 @@ void Server::ChannelData::Destroy() {
   list_position_.reset();
   server_->Ref().release();
   server_->MaybeFinishShutdown();
+  // Unreffed by FinishDestroy
+  GRPC_CHANNEL_STACK_REF(channel_->channel_stack(),
+                         "Server::ChannelData::Destroy");
   GRPC_CLOSURE_INIT(&finish_destroy_channel_closure_, FinishDestroy, this,
                     grpc_schedule_on_exec_ctx);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_server_channel_trace)) {
@@ -1147,9 +1384,8 @@ void Server::ChannelData::Destroy() {
   grpc_transport_op* op =
       grpc_make_transport_op(&finish_destroy_channel_closure_);
   op->set_accept_stream = true;
-  grpc_channel_next_op(
-      grpc_channel_stack_element(grpc_channel_get_channel_stack(channel_), 0),
-      op);
+  grpc_channel_next_op(grpc_channel_stack_element(channel_->channel_stack(), 0),
+                       op);
 }
 
 grpc_error_handle Server::ChannelData::InitChannelElement(
@@ -1157,7 +1393,7 @@ grpc_error_handle Server::ChannelData::InitChannelElement(
   GPR_ASSERT(args->is_first);
   GPR_ASSERT(!args->is_last);
   new (elem->channel_data) ChannelData();
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 void Server::ChannelData::DestroyChannelElement(grpc_channel_element* elem) {
@@ -1183,7 +1419,6 @@ Server::CallData::CallData(grpc_call_element* elem,
 
 Server::CallData::~CallData() {
   GPR_ASSERT(state_.load(std::memory_order_relaxed) != CallState::PENDING);
-  GRPC_ERROR_UNREF(recv_initial_metadata_error_);
   grpc_metadata_array_destroy(&initial_metadata_);
   grpc_byte_buffer_destroy(payload_);
 }
@@ -1236,12 +1471,10 @@ void Server::CallData::Publish(size_t cq_idx, RequestedCall* rc) {
     case RequestedCall::Type::BATCH_CALL:
       GPR_ASSERT(host_.has_value());
       GPR_ASSERT(path_.has_value());
-      rc->data.batch.details->host = grpc_slice_ref_internal(host_->c_slice());
-      rc->data.batch.details->method =
-          grpc_slice_ref_internal(path_->c_slice());
+      rc->data.batch.details->host = CSliceRef(host_->c_slice());
+      rc->data.batch.details->method = CSliceRef(path_->c_slice());
       rc->data.batch.details->deadline =
           deadline_.as_timespec(GPR_CLOCK_MONOTONIC);
-      rc->data.batch.details->flags = recv_initial_metadata_flags_;
       break;
     case RequestedCall::Type::REGISTERED_CALL:
       *rc->data.registered.deadline =
@@ -1252,9 +1485,9 @@ void Server::CallData::Publish(size_t cq_idx, RequestedCall* rc) {
       }
       break;
     default:
-      GPR_UNREACHABLE_CODE(return );
+      GPR_UNREACHABLE_CODE(return);
   }
-  grpc_cq_end_op(cq_new_, rc->tag, GRPC_ERROR_NONE, Server::DoneRequestEvent,
+  grpc_cq_end_op(cq_new_, rc->tag, absl::OkStatus(), Server::DoneRequestEvent,
                  rc, &rc->completion, true);
 }
 
@@ -1264,7 +1497,7 @@ void Server::CallData::PublishNewRpc(void* arg, grpc_error_handle error) {
   auto* chand = static_cast<Server::ChannelData*>(call_elem->channel_data);
   RequestMatcherInterface* rm = calld->matcher_;
   Server* server = rm->server();
-  if (error != GRPC_ERROR_NONE || server->ShutdownCalled()) {
+  if (!error.ok() || server->ShutdownCalled()) {
     calld->state_.store(CallState::ZOMBIED, std::memory_order_relaxed);
     calld->KillZombie();
     return;
@@ -1283,9 +1516,10 @@ void KillZombieClosure(void* call, grpc_error_handle /*error*/) {
 void Server::CallData::KillZombie() {
   GRPC_CLOSURE_INIT(&kill_zombie_closure_, KillZombieClosure, call_,
                     grpc_schedule_on_exec_ctx);
-  ExecCtx::Run(DEBUG_LOCATION, &kill_zombie_closure_, GRPC_ERROR_NONE);
+  ExecCtx::Run(DEBUG_LOCATION, &kill_zombie_closure_, absl::OkStatus());
 }
 
+// If this changes, change MakeCallPromise too.
 void Server::CallData::StartNewRpc(grpc_call_element* elem) {
   auto* chand = static_cast<ChannelData*>(elem->channel_data);
   if (server_->ShutdownCalled()) {
@@ -1299,9 +1533,7 @@ void Server::CallData::StartNewRpc(grpc_call_element* elem) {
       GRPC_SRM_PAYLOAD_NONE;
   if (path_.has_value() && host_.has_value()) {
     ChannelRegisteredMethod* rm =
-        chand->GetRegisteredMethod(host_->c_slice(), path_->c_slice(),
-                                   (recv_initial_metadata_flags_ &
-                                    GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST));
+        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;
@@ -1310,7 +1542,7 @@ void Server::CallData::StartNewRpc(grpc_call_element* elem) {
   // Start recv_message op if needed.
   switch (payload_handling) {
     case GRPC_SRM_PAYLOAD_NONE:
-      PublishNewRpc(elem, GRPC_ERROR_NONE);
+      PublishNewRpc(elem, absl::OkStatus());
       break;
     case GRPC_SRM_PAYLOAD_READ_INITIAL_BYTE_BUFFER: {
       grpc_op op;
@@ -1330,9 +1562,9 @@ void Server::CallData::RecvInitialMetadataBatchComplete(
     void* arg, grpc_error_handle error) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(arg);
   auto* calld = static_cast<Server::CallData*>(elem->call_data);
-  if (error != GRPC_ERROR_NONE) {
+  if (!error.ok()) {
     gpr_log(GPR_DEBUG, "Failed call creation: %s",
-            grpc_error_std_string(error).c_str());
+            StatusToString(error).c_str());
     calld->FailCallCreation();
     return;
   }
@@ -1342,15 +1574,12 @@ void Server::CallData::RecvInitialMetadataBatchComplete(
 void Server::CallData::StartTransportStreamOpBatchImpl(
     grpc_call_element* elem, grpc_transport_stream_op_batch* batch) {
   if (batch->recv_initial_metadata) {
-    GPR_ASSERT(batch->payload->recv_initial_metadata.recv_flags == nullptr);
     recv_initial_metadata_ =
         batch->payload->recv_initial_metadata.recv_initial_metadata;
     original_recv_initial_metadata_ready_ =
         batch->payload->recv_initial_metadata.recv_initial_metadata_ready;
     batch->payload->recv_initial_metadata.recv_initial_metadata_ready =
         &recv_initial_metadata_ready_;
-    batch->payload->recv_initial_metadata.recv_flags =
-        &recv_initial_metadata_flags_;
   }
   if (batch->recv_trailing_metadata) {
     original_recv_trailing_metadata_ready_ =
@@ -1365,25 +1594,22 @@ void Server::CallData::RecvInitialMetadataReady(void* arg,
                                                 grpc_error_handle error) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(arg);
   CallData* calld = static_cast<CallData*>(elem->call_data);
-  if (error == GRPC_ERROR_NONE) {
+  if (error.ok()) {
     calld->path_ = calld->recv_initial_metadata_->Take(HttpPathMetadata());
-    calld->host_ = calld->recv_initial_metadata_->Take(HttpAuthorityMetadata());
-  } else {
-    (void)GRPC_ERROR_REF(error);
+    auto* host =
+        calld->recv_initial_metadata_->get_pointer(HttpAuthorityMetadata());
+    if (host != nullptr) calld->host_.emplace(host->Ref());
   }
   auto op_deadline = calld->recv_initial_metadata_->get(GrpcTimeoutMetadata());
   if (op_deadline.has_value()) {
     calld->deadline_ = *op_deadline;
   }
   if (calld->host_.has_value() && calld->path_.has_value()) {
-    /* do nothing */
-  } else {
-    /* Pass the error reference to calld->recv_initial_metadata_error */
-    grpc_error_handle src_error = error;
-    error = GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-        "Missing :authority or :path", &src_error, 1);
-    GRPC_ERROR_UNREF(src_error);
-    calld->recv_initial_metadata_error_ = GRPC_ERROR_REF(error);
+    // do nothing
+  } else if (error.ok()) {
+    // Pass the error reference to calld->recv_initial_metadata_error
+    error = absl::UnknownError("Missing :authority or :path");
+    calld->recv_initial_metadata_error_ = error;
   }
   grpc_closure* closure = calld->original_recv_initial_metadata_ready_;
   calld->original_recv_initial_metadata_ready_ = nullptr;
@@ -1401,7 +1627,7 @@ void Server::CallData::RecvTrailingMetadataReady(void* arg,
   grpc_call_element* elem = static_cast<grpc_call_element*>(arg);
   CallData* calld = static_cast<CallData*>(elem->call_data);
   if (calld->original_recv_initial_metadata_ready_ != nullptr) {
-    calld->recv_trailing_metadata_error_ = GRPC_ERROR_REF(error);
+    calld->recv_trailing_metadata_error_ = error;
     calld->seen_recv_trailing_metadata_ready_ = true;
     GRPC_CLOSURE_INIT(&calld->recv_trailing_metadata_ready_,
                       RecvTrailingMetadataReady, elem,
@@ -1411,9 +1637,7 @@ void Server::CallData::RecvTrailingMetadataReady(void* arg,
                             "until after recv_initial_metadata_ready");
     return;
   }
-  error =
-      grpc_error_add_child(GRPC_ERROR_REF(error),
-                           GRPC_ERROR_REF(calld->recv_initial_metadata_error_));
+  error = grpc_error_add_child(error, calld->recv_initial_metadata_error_);
   Closure::Run(DEBUG_LOCATION, calld->original_recv_trailing_metadata_ready_,
                error);
 }
@@ -1422,7 +1646,7 @@ grpc_error_handle Server::CallData::InitCallElement(
     grpc_call_element* elem, const grpc_call_element_args* args) {
   auto* chand = static_cast<ChannelData*>(elem->channel_data);
   new (elem->call_data) Server::CallData(elem, *args, chand->server());
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 void Server::CallData::DestroyCallElement(
@@ -1447,11 +1671,10 @@ void Server::CallData::StartTransportStreamOpBatch(
 grpc_server* grpc_server_create(const grpc_channel_args* args, void* reserved) {
   grpc_core::ExecCtx exec_ctx;
   GRPC_API_TRACE("grpc_server_create(%p, %p)", 2, (args, reserved));
-  const grpc_channel_args* new_args = grpc_core::CoreConfiguration::Get()
-                                          .channel_args_preconditioning()
-                                          .PreconditionChannelArgs(args);
-  grpc_core::Server* server = new grpc_core::Server(new_args);
-  grpc_channel_args_destroy(new_args);
+  grpc_core::Server* server =
+      new grpc_core::Server(grpc_core::CoreConfiguration::Get()
+                                .channel_args_preconditioning()
+                                .PreconditionChannelArgs(args));
   return server->c_ptr();
 }
 
@@ -1468,8 +1691,8 @@ void grpc_server_register_completion_queue(grpc_server* server,
             "Completion queue of type %d is being registered as a "
             "server-completion-queue",
             static_cast<int>(cq_type));
-    /* Ideally we should log an error and abort but ruby-wrapped-language API
-       calls grpc_completion_queue_pluck() on server completion queues */
+    // Ideally we should log an error and abort but ruby-wrapped-language API
+    // calls grpc_completion_queue_pluck() on server completion queues
   }
   grpc_core::Server::FromC(server)->RegisterCompletionQueue(cq);
 }
@@ -1522,7 +1745,6 @@ grpc_call_error grpc_server_request_call(
     grpc_completion_queue* cq_for_notification, void* tag) {
   grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
-  GRPC_STATS_INC_SERVER_REQUESTED_CALLS();
   GRPC_API_TRACE(
       "grpc_server_request_call("
       "server=%p, call=%p, details=%p, initial_metadata=%p, "
@@ -1543,7 +1765,6 @@ grpc_call_error grpc_server_request_registered_call(
     grpc_completion_queue* cq_for_notification, void* tag_new) {
   grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
-  GRPC_STATS_INC_SERVER_REQUESTED_CALLS();
   auto* rm =
       static_cast<grpc_core::Server::RegisteredMethod*>(registered_method);
   GRPC_API_TRACE(