grpc 1.30.0 → 1.46.3

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

@@ -1,20 +1,18 @@
-/*
- *
- * Copyright 2015-2016 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.
- *
- */
+//
+// Copyright 2015-2016 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
 
 #include <grpc/support/port_platform.h>
 
@@ -24,12 +22,21 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include <algorithm>
+#include <atomic>
+#include <iterator>
+#include <list>
+#include <queue>
+#include <utility>
+#include <vector>
+
+#include "absl/memory/memory.h"
+#include "absl/types/optional.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
-#include <utility>
-
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/channel/connected_channel.h"
@@ -39,43 +46,29 @@
 #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/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/completion_queue.h"
 #include "src/core/lib/surface/init.h"
-#include "src/core/lib/transport/metadata.h"
-#include "src/core/lib/transport/static_metadata.h"
-
-grpc_core::TraceFlag grpc_server_channel_trace(false, "server_channel");
-
-using grpc_core::LockedMultiProducerSingleConsumerQueue;
 
-namespace {
+namespace grpc_core {
 
-void server_on_recv_initial_metadata(void* ptr, grpc_error* error);
-void server_recv_trailing_metadata_ready(void* user_data, grpc_error* error);
-
-struct listener {
-  void* arg;
-  void (*start)(grpc_server* server, void* arg, grpc_pollset** pollsets,
-                size_t pollset_count);
-  void (*destroy)(grpc_server* server, void* arg, grpc_closure* closure);
-  struct listener* next;
-  intptr_t socket_uuid;
-  grpc_closure destroy_done;
-};
+TraceFlag grpc_server_channel_trace(false, "server_channel");
 
-enum requested_call_type { BATCH_CALL, REGISTERED_CALL };
+//
+// Server::RequestedCall
+//
 
-struct registered_method;
+struct Server::RequestedCall {
+  enum class Type { BATCH_CALL, REGISTERED_CALL };
 
-struct requested_call {
-  requested_call(void* tag_arg, grpc_completion_queue* call_cq,
-                 grpc_call** call_arg, grpc_metadata_array* initial_md,
-                 grpc_call_details* details)
-      : type(BATCH_CALL),
+  RequestedCall(void* tag_arg, grpc_completion_queue* call_cq,
+                grpc_call** call_arg, grpc_metadata_array* initial_md,
+                grpc_call_details* details)
+      : type(Type::BATCH_CALL),
         tag(tag_arg),
         cq_bound_to_call(call_cq),
         call(call_arg),
@@ -84,11 +77,11 @@ struct requested_call {
     data.batch.details = details;
   }
 
-  requested_call(void* tag_arg, grpc_completion_queue* call_cq,
-                 grpc_call** call_arg, grpc_metadata_array* initial_md,
-                 registered_method* rm, gpr_timespec* deadline,
-                 grpc_byte_buffer** optional_payload)
-      : type(REGISTERED_CALL),
+  RequestedCall(void* tag_arg, grpc_completion_queue* call_cq,
+                grpc_call** call_arg, grpc_metadata_array* initial_md,
+                RegisteredMethod* rm, gpr_timespec* deadline,
+                grpc_byte_buffer** optional_payload)
+      : type(Type::REGISTERED_CALL),
         tag(tag_arg),
         cq_bound_to_call(call_cq),
         call(call_arg),
@@ -98,8 +91,8 @@ struct requested_call {
     data.registered.optional_payload = optional_payload;
   }
 
-  grpc_core::MultiProducerSingleConsumerQueue::Node mpscq_node;
-  const requested_call_type type;
+  MultiProducerSingleConsumerQueue::Node mpscq_node;
+  const Type type;
   void* const tag;
   grpc_completion_queue* const cq_bound_to_call;
   grpc_call** const call;
@@ -110,57 +103,40 @@ struct requested_call {
       grpc_call_details* details;
     } batch;
     struct {
-      registered_method* method;
+      RegisteredMethod* method;
       gpr_timespec* deadline;
       grpc_byte_buffer** optional_payload;
     } registered;
   } data;
 };
 
-struct channel_registered_method {
-  registered_method* server_registered_method;
-  uint32_t flags;
-  bool has_host;
-  grpc_core::ExternallyManagedSlice method;
-  grpc_core::ExternallyManagedSlice host;
-};
+//
+// Server::RegisteredMethod
+//
 
-struct channel_data {
-  grpc_server* server;
-  grpc_channel* channel;
-  size_t cq_idx;
-  /* linked list of all channels on a server */
-  channel_data* next;
-  channel_data* prev;
-  channel_registered_method* registered_methods;
-  uint32_t registered_method_slots;
-  uint32_t registered_method_max_probes;
-  grpc_closure finish_destroy_channel_closure;
-  intptr_t channelz_socket_uuid;
-};
+struct Server::RegisteredMethod {
+  RegisteredMethod(
+      const char* method_arg, const char* host_arg,
+      grpc_server_register_method_payload_handling payload_handling_arg,
+      uint32_t flags_arg)
+      : method(method_arg == nullptr ? "" : method_arg),
+        host(host_arg == nullptr ? "" : host_arg),
+        payload_handling(payload_handling_arg),
+        flags(flags_arg) {}
 
-struct shutdown_tag {
-  void* tag;
-  grpc_completion_queue* cq;
-  grpc_cq_completion completion;
-};
+  ~RegisteredMethod() = default;
 
-enum call_state {
-  /* waiting for metadata */
-  NOT_STARTED,
-  /* initial metadata read, not flow controlled in yet */
-  PENDING,
-  /* flow controlled in, on completion queue */
-  ACTIVATED,
-  /* cancelled before being queued */
-  ZOMBIED
+  const std::string method;
+  const std::string host;
+  const grpc_server_register_method_payload_handling payload_handling;
+  const uint32_t flags;
+  // One request matcher per method.
+  std::unique_ptr<RequestMatcherInterface> matcher;
 };
 
-struct call_data;
-
-grpc_call_error ValidateServerRequest(
-    grpc_completion_queue* cq_for_notification, void* tag,
-    grpc_byte_buffer** optional_payload, registered_method* rm);
+//
+// Server::RequestMatcherInterface
+//
 
 // RPCs that come in from the transport must be matched against RPC requests
 // from the application. An incoming request from the application can be matched
@@ -171,7 +147,7 @@ grpc_call_error ValidateServerRequest(
 // on the request's notification CQ.
 //
 // RequestMatcherInterface is the base class to provide this functionality.
-class RequestMatcherInterface {
+class Server::RequestMatcherInterface {
  public:
   virtual ~RequestMatcherInterface() {}
 
@@ -182,7 +158,7 @@ class RequestMatcherInterface {
   // Mark all application-requested RPCs failed if they have not been matched to
   // an incoming RPC. The error parameter indicates why the RPCs are being
   // failed (always server shutdown in all current implementations).
-  virtual void KillRequests(grpc_error* error) = 0;
+  virtual void KillRequests(grpc_error_handle error) = 0;
 
   // How many request queues are supported by this matcher. This is an abstract
   // concept that essentially maps to gRPC completion queues.
@@ -194,7 +170,7 @@ class RequestMatcherInterface {
   // CQ. If there are pending RPCs waiting to be matched, publish one (match it
   // and notify the CQ).
   virtual void RequestCallWithPossiblePublish(size_t request_queue_index,
-                                              requested_call* call) = 0;
+                                              RequestedCall* call) = 0;
 
   // This function is invoked on an incoming RPC, represented by the calld
   // object. The RequestMatcher will try to match it against an
@@ -203,248 +179,21 @@ class RequestMatcherInterface {
   // is done starting at the start_request_queue_index parameter in a cyclic
   // order rather than always starting at 0.
   virtual void MatchOrQueue(size_t start_request_queue_index,
-                            call_data* calld) = 0;
+                            CallData* calld) = 0;
 
   // Returns the server associated with this request matcher
-  virtual grpc_server* server() const = 0;
-};
-
-struct call_data {
-  call_data(grpc_call_element* elem, const grpc_call_element_args& args)
-      : call(grpc_call_from_top_element(elem)),
-        call_combiner(args.call_combiner) {
-    GRPC_CLOSURE_INIT(&server_on_recv_initial_metadata,
-                      ::server_on_recv_initial_metadata, elem,
-                      grpc_schedule_on_exec_ctx);
-    GRPC_CLOSURE_INIT(&recv_trailing_metadata_ready,
-                      ::server_recv_trailing_metadata_ready, elem,
-                      grpc_schedule_on_exec_ctx);
-  }
-  ~call_data() {
-    GPR_ASSERT(state != PENDING);
-    GRPC_ERROR_UNREF(recv_initial_metadata_error);
-    if (host_set) {
-      grpc_slice_unref_internal(host);
-    }
-    if (path_set) {
-      grpc_slice_unref_internal(path);
-    }
-    grpc_metadata_array_destroy(&initial_metadata);
-    grpc_byte_buffer_destroy(payload);
-  }
-
-  grpc_call* call;
-
-  gpr_atm state = NOT_STARTED;
-
-  bool path_set = false;
-  bool host_set = false;
-  grpc_slice path;
-  grpc_slice host;
-  grpc_millis deadline = GRPC_MILLIS_INF_FUTURE;
-
-  grpc_completion_queue* cq_new = nullptr;
-
-  grpc_metadata_batch* recv_initial_metadata = nullptr;
-  uint32_t recv_initial_metadata_flags = 0;
-  grpc_metadata_array initial_metadata =
-      grpc_metadata_array();  // Zero-initialize the C struct.
-
-  RequestMatcherInterface* matcher = nullptr;
-  grpc_byte_buffer* payload = nullptr;
-
-  grpc_closure got_initial_metadata;
-  grpc_closure server_on_recv_initial_metadata;
-  grpc_closure kill_zombie_closure;
-  grpc_closure* on_done_recv_initial_metadata;
-  grpc_closure recv_trailing_metadata_ready;
-  grpc_error* recv_initial_metadata_error = GRPC_ERROR_NONE;
-  grpc_closure* original_recv_trailing_metadata_ready;
-  grpc_error* recv_trailing_metadata_error = GRPC_ERROR_NONE;
-  bool seen_recv_trailing_metadata_ready = false;
-
-  grpc_closure publish;
-
-  call_data* pending_next = nullptr;
-  grpc_core::CallCombiner* call_combiner;
-};
-
-struct registered_method {
-  registered_method(
-      const char* method_arg, const char* host_arg,
-      grpc_server_register_method_payload_handling payload_handling_arg,
-      uint32_t flags_arg)
-      : method(method_arg == nullptr ? "" : method_arg),
-        host(host_arg == nullptr ? "" : host_arg),
-        payload_handling(payload_handling_arg),
-        flags(flags_arg) {}
-
-  ~registered_method() = default;
-
-  const std::string method;
-  const std::string host;
-  const grpc_server_register_method_payload_handling payload_handling;
-  const uint32_t flags;
-  /* one request matcher per method */
-  std::unique_ptr<RequestMatcherInterface> matcher;
-  registered_method* next;
-};
-
-struct channel_broadcaster {
-  grpc_channel** channels;
-  size_t num_channels;
-};
-}  // namespace
-
-struct grpc_server {
-  grpc_channel_args* channel_args;
-
-  grpc_resource_user* default_resource_user;
-
-  grpc_completion_queue** cqs;
-  grpc_pollset** pollsets;
-  size_t cq_count;
-  size_t pollset_count;
-  bool started;
-
-  /* The two following mutexes control access to server-state
-     mu_global controls access to non-call-related state (e.g., channel state)
-     mu_call controls access to call-related state (e.g., the call lists)
-
-     If they are ever required to be nested, you must lock mu_global
-     before mu_call. This is currently used in shutdown processing
-     (grpc_server_shutdown_and_notify and maybe_finish_shutdown) */
-  gpr_mu mu_global; /* mutex for server and channel state */
-  gpr_mu mu_call;   /* mutex for call-specific state */
-
-  /* startup synchronization: flag is protected by mu_global, signals whether
-     we are doing the listener start routine or not */
-  bool starting;
-  gpr_cv starting_cv;
-
-  // TODO(vjpai): Convert from a linked-list head pointer to a std::vector once
-  // grpc_server has a real constructor/destructor
-  registered_method* registered_methods;
-  /** one request matcher for unregistered methods */
-  // TODO(vjpai): Convert to a std::unique_ptr once grpc_server has a real
-  // constructor and destructor.
-  RequestMatcherInterface* unregistered_request_matcher;
-
-  gpr_atm shutdown_flag;
-  uint8_t shutdown_published;
-  size_t num_shutdown_tags;
-  shutdown_tag* shutdown_tags;
-
-  channel_data root_channel_data;
-
-  listener* listeners;
-  int listeners_destroyed;
-  grpc_core::RefCount internal_refcount;
-
-  /** when did we print the last shutdown progress message */
-  gpr_timespec last_shutdown_message_time;
-
-  grpc_core::RefCountedPtr<grpc_core::channelz::ServerNode> channelz_server;
-};
-
-#define SERVER_FROM_CALL_ELEM(elem) \
-  (((channel_data*)(elem)->channel_data)->server)
-
-namespace {
-void publish_call(grpc_server* server, call_data* calld, size_t cq_idx,
-                  requested_call* rc);
-void fail_call(grpc_server* server, size_t cq_idx, requested_call* rc,
-               grpc_error* error);
-/* Before calling maybe_finish_shutdown, we must hold mu_global and not
-   hold mu_call */
-void maybe_finish_shutdown(grpc_server* server);
-
-void kill_zombie(void* elem, grpc_error* /*error*/) {
-  grpc_call_unref(
-      grpc_call_from_top_element(static_cast<grpc_call_element*>(elem)));
-}
-
-/*
- * channel broadcaster
- */
-
-/* assumes server locked */
-void channel_broadcaster_init(grpc_server* s, channel_broadcaster* cb) {
-  channel_data* c;
-  size_t count = 0;
-  for (c = s->root_channel_data.next; c != &s->root_channel_data; c = c->next) {
-    count++;
-  }
-  cb->num_channels = count;
-  cb->channels = static_cast<grpc_channel**>(
-      gpr_malloc(sizeof(*cb->channels) * cb->num_channels));
-  count = 0;
-  for (c = s->root_channel_data.next; c != &s->root_channel_data; c = c->next) {
-    cb->channels[count++] = c->channel;
-    GRPC_CHANNEL_INTERNAL_REF(c->channel, "broadcast");
-  }
-}
-
-struct shutdown_cleanup_args {
-  grpc_closure closure;
-  grpc_slice slice;
+  virtual Server* server() const = 0;
 };
 
-void shutdown_cleanup(void* arg, grpc_error* /*error*/) {
-  struct shutdown_cleanup_args* a =
-      static_cast<struct shutdown_cleanup_args*>(arg);
-  grpc_slice_unref_internal(a->slice);
-  gpr_free(a);
-}
-
-void send_shutdown(grpc_channel* channel, bool send_goaway,
-                   grpc_error* send_disconnect) {
-  struct shutdown_cleanup_args* sc =
-      static_cast<struct shutdown_cleanup_args*>(gpr_malloc(sizeof(*sc)));
-  GRPC_CLOSURE_INIT(&sc->closure, shutdown_cleanup, sc,
-                    grpc_schedule_on_exec_ctx);
-  grpc_transport_op* op = grpc_make_transport_op(&sc->closure);
-  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;
-  sc->slice = grpc_slice_from_copied_string("Server shutdown");
-  op->disconnect_with_error = send_disconnect;
-
-  elem = grpc_channel_stack_element(grpc_channel_get_channel_stack(channel), 0);
-  elem->filter->start_transport_op(elem, op);
-}
-
-void channel_broadcaster_shutdown(channel_broadcaster* cb, bool send_goaway,
-                                  grpc_error* force_disconnect) {
-  size_t i;
-
-  for (i = 0; i < cb->num_channels; i++) {
-    send_shutdown(cb->channels[i], send_goaway,
-                  GRPC_ERROR_REF(force_disconnect));
-    GRPC_CHANNEL_INTERNAL_UNREF(cb->channels[i], "broadcast");
-  }
-  gpr_free(cb->channels);
-  GRPC_ERROR_UNREF(force_disconnect);
-}
-
-/*
- * request_matcher
- */
-
 // The RealRequestMatcher is an implementation of RequestMatcherInterface that
 // actually uses all the features of RequestMatcherInterface: expecting the
 // application to explicitly request RPCs and then matching those to incoming
 // RPCs, along with a slow path by which incoming RPCs are put on a locked
 // pending list if they aren't able to be matched to an application request.
-class RealRequestMatcher : public RequestMatcherInterface {
+class Server::RealRequestMatcher : public RequestMatcherInterface {
  public:
-  explicit RealRequestMatcher(grpc_server* server)
-      : server_(server), requests_per_cq_(server->cq_count) {}
+  explicit RealRequestMatcher(Server* server)
+      : server_(server), requests_per_cq_(server->cqs_.size()) {}
 
   ~RealRequestMatcher() override {
     for (LockedMultiProducerSingleConsumerQueue& queue : requests_per_cq_) {
@@ -453,25 +202,20 @@ class RealRequestMatcher : public RequestMatcherInterface {
   }
 
   void ZombifyPending() override {
-    while (pending_head_ != nullptr) {
-      call_data* calld = pending_head_;
-      pending_head_ = calld->pending_next;
-      gpr_atm_no_barrier_store(&calld->state, ZOMBIED);
-      GRPC_CLOSURE_INIT(
-          &calld->kill_zombie_closure, kill_zombie,
-          grpc_call_stack_element(grpc_call_get_call_stack(calld->call), 0),
-          grpc_schedule_on_exec_ctx);
-      grpc_core::ExecCtx::Run(DEBUG_LOCATION, &calld->kill_zombie_closure,
-                              GRPC_ERROR_NONE);
+    while (!pending_.empty()) {
+      CallData* calld = pending_.front();
+      calld->SetState(CallData::CallState::ZOMBIED);
+      calld->KillZombie();
+      pending_.pop();
     }
   }
 
-  void KillRequests(grpc_error* error) override {
+  void KillRequests(grpc_error_handle error) override {
     for (size_t i = 0; i < requests_per_cq_.size(); i++) {
-      requested_call* rc;
-      while ((rc = reinterpret_cast<requested_call*>(
+      RequestedCall* rc;
+      while ((rc = reinterpret_cast<RequestedCall*>(
                   requests_per_cq_[i].Pop())) != nullptr) {
-        fail_call(server_, i, rc, GRPC_ERROR_REF(error));
+        server_->FailCall(i, rc, GRPC_ERROR_REF(error));
       }
     }
     GRPC_ERROR_UNREF(error);
@@ -482,90 +226,90 @@ class RealRequestMatcher : public RequestMatcherInterface {
   }
 
   void RequestCallWithPossiblePublish(size_t request_queue_index,
-                                      requested_call* call) override {
+                                      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 */
-      gpr_mu_lock(&server_->mu_call);
-      call_data* calld;
-      while ((calld = pending_head_) != nullptr) {
-        requested_call* rc = reinterpret_cast<requested_call*>(
-            requests_per_cq_[request_queue_index].Pop());
-        if (rc == nullptr) break;
-        pending_head_ = calld->pending_next;
-        gpr_mu_unlock(&server_->mu_call);
-        if (!gpr_atm_full_cas(&calld->state, PENDING, ACTIVATED)) {
+      struct PendingCall {
+        RequestedCall* rc = nullptr;
+        CallData* calld;
+      };
+      auto pop_next_pending = [this, request_queue_index] {
+        PendingCall 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_.pop();
+            }
+          }
+        }
+        return pending_call;
+      };
+      while (true) {
+        PendingCall next_pending = pop_next_pending();
+        if (next_pending.rc == nullptr) break;
+        if (!next_pending.calld->MaybeActivate()) {
           // Zombied Call
-          GRPC_CLOSURE_INIT(
-              &calld->kill_zombie_closure, kill_zombie,
-              grpc_call_stack_element(grpc_call_get_call_stack(calld->call), 0),
-              grpc_schedule_on_exec_ctx);
-          grpc_core::ExecCtx::Run(DEBUG_LOCATION, &calld->kill_zombie_closure,
-                                  GRPC_ERROR_NONE);
+          next_pending.calld->KillZombie();
         } else {
-          publish_call(server_, calld, request_queue_index, rc);
+          next_pending.calld->Publish(request_queue_index, next_pending.rc);
         }
-        gpr_mu_lock(&server_->mu_call);
       }
-      gpr_mu_unlock(&server_->mu_call);
     }
   }
 
   void MatchOrQueue(size_t start_request_queue_index,
-                    call_data* calld) override {
+                    CallData* calld) 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();
-      requested_call* rc =
-          reinterpret_cast<requested_call*>(requests_per_cq_[cq_idx].TryPop());
-      if (rc == nullptr) {
-        continue;
-      } else {
+      RequestedCall* rc =
+          reinterpret_cast<RequestedCall*>(requests_per_cq_[cq_idx].TryPop());
+      if (rc != nullptr) {
         GRPC_STATS_INC_SERVER_CQS_CHECKED(i);
-        gpr_atm_no_barrier_store(&calld->state, ACTIVATED);
-        publish_call(server_, calld, cq_idx, rc);
-        return; /* early out */
+        calld->SetState(CallData::CallState::ACTIVATED);
+        calld->Publish(cq_idx, rc);
+        return;
       }
     }
-
-    /* no cq to take the request found: queue it on the slow list */
+    // No cq to take the request found; queue it on the slow list.
     GRPC_STATS_INC_SERVER_SLOWPATH_REQUESTS_QUEUED();
-    gpr_mu_lock(&server_->mu_call);
-
     // 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
+    // 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.
-    for (size_t i = 0; i < requests_per_cq_.size(); i++) {
-      size_t cq_idx = (start_request_queue_index + i) % requests_per_cq_.size();
-      requested_call* rc =
-          reinterpret_cast<requested_call*>(requests_per_cq_[cq_idx].Pop());
+    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) {
-        continue;
-      } else {
-        gpr_mu_unlock(&server_->mu_call);
-        GRPC_STATS_INC_SERVER_CQS_CHECKED(i + requests_per_cq_.size());
-        gpr_atm_no_barrier_store(&calld->state, ACTIVATED);
-        publish_call(server_, calld, cq_idx, rc);
-        return; /* early out */
+        calld->SetState(CallData::CallState::PENDING);
+        pending_.push(calld);
+        return;
       }
     }
-
-    gpr_atm_no_barrier_store(&calld->state, PENDING);
-    if (pending_head_ == nullptr) {
-      pending_tail_ = pending_head_ = calld;
-    } else {
-      pending_tail_->pending_next = calld;
-      pending_tail_ = calld;
-    }
-    gpr_mu_unlock(&server_->mu_call);
+    GRPC_STATS_INC_SERVER_CQS_CHECKED(loop_count + requests_per_cq_.size());
+    calld->SetState(CallData::CallState::ACTIVATED);
+    calld->Publish(cq_idx, rc);
   }
 
-  grpc_server* server() const override { return server_; }
+  Server* server() const override { return server_; }
 
  private:
-  grpc_server* const server_;
-  call_data* pending_head_ = nullptr;
-  call_data* pending_tail_ = nullptr;
+  Server* const server_;
+  std::queue<CallData*> pending_;
   std::vector<LockedMultiProducerSingleConsumerQueue> requests_per_cq_;
 };
 
@@ -573,33 +317,36 @@ class RealRequestMatcher : public RequestMatcherInterface {
 // advance or queue up any incoming RPC for later match. Instead, MatchOrQueue
 // will call out to an allocation function passed in at the construction of the
 // object. These request matchers are designed for the C++ callback API, so they
-// only support 1 completion queue (passed in at the constructor).
-class AllocatingRequestMatcherBase : public RequestMatcherInterface {
+// only support 1 completion queue (passed in at the constructor). They are also
+// used for the sync API.
+class Server::AllocatingRequestMatcherBase : public RequestMatcherInterface {
  public:
-  AllocatingRequestMatcherBase(grpc_server* server, grpc_completion_queue* cq)
+  AllocatingRequestMatcherBase(Server* server, grpc_completion_queue* cq)
       : server_(server), cq_(cq) {
     size_t idx;
-    for (idx = 0; idx < server->cq_count; idx++) {
-      if (server->cqs[idx] == cq) {
+    for (idx = 0; idx < server->cqs_.size(); idx++) {
+      if (server->cqs_[idx] == cq) {
         break;
       }
     }
-    GPR_ASSERT(idx < server->cq_count);
+    GPR_ASSERT(idx < server->cqs_.size());
     cq_idx_ = idx;
   }
 
   void ZombifyPending() override {}
 
-  void KillRequests(grpc_error* error) override { GRPC_ERROR_UNREF(error); }
+  void KillRequests(grpc_error_handle error) override {
+    GRPC_ERROR_UNREF(error);
+  }
 
   size_t request_queue_count() const override { return 0; }
 
   void RequestCallWithPossiblePublish(size_t /*request_queue_index*/,
-                                      requested_call* /*call*/) final {
+                                      RequestedCall* /*call*/) final {
     GPR_ASSERT(false);
   }
 
-  grpc_server* server() const override { return server_; }
+  Server* server() const override { return server_; }
 
   // Supply the completion queue related to this request matcher
   grpc_completion_queue* cq() const { return cq_; }
@@ -608,634 +355,559 @@ class AllocatingRequestMatcherBase : public RequestMatcherInterface {
   size_t cq_idx() const { return cq_idx_; }
 
  private:
-  grpc_server* const server_;
+  Server* const server_;
   grpc_completion_queue* const cq_;
   size_t cq_idx_;
 };
 
 // An allocating request matcher for non-registered methods (used for generic
 // API and unimplemented RPCs).
-class AllocatingRequestMatcherBatch : public AllocatingRequestMatcherBase {
+class Server::AllocatingRequestMatcherBatch
+    : public AllocatingRequestMatcherBase {
  public:
-  AllocatingRequestMatcherBatch(
-      grpc_server* server, grpc_completion_queue* cq,
-      std::function<grpc_core::ServerBatchCallAllocation()> allocator)
+  AllocatingRequestMatcherBatch(Server* server, grpc_completion_queue* cq,
+                                std::function<BatchCallAllocation()> allocator)
       : AllocatingRequestMatcherBase(server, cq),
         allocator_(std::move(allocator)) {}
+
   void MatchOrQueue(size_t /*start_request_queue_index*/,
-                    call_data* calld) override {
-    grpc_core::ServerBatchCallAllocation call_info = allocator_();
-    GPR_ASSERT(ValidateServerRequest(cq(), static_cast<void*>(call_info.tag),
-                                     nullptr, nullptr) == GRPC_CALL_OK);
-    requested_call* rc = new requested_call(
-        static_cast<void*>(call_info.tag), cq(), call_info.call,
-        call_info.initial_metadata, call_info.details);
-    gpr_atm_no_barrier_store(&calld->state, ACTIVATED);
-    publish_call(server(), calld, cq_idx(), rc);
+                    CallData* calld) override {
+    if (server()->ShutdownRefOnRequest()) {
+      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);
+      calld->SetState(CallData::CallState::ACTIVATED);
+      calld->Publish(cq_idx(), rc);
+    } else {
+      calld->FailCallCreation();
+    }
+    server()->ShutdownUnrefOnRequest();
   }
 
  private:
-  std::function<grpc_core::ServerBatchCallAllocation()> allocator_;
+  std::function<BatchCallAllocation()> allocator_;
 };
 
 // An allocating request matcher for registered methods.
-class AllocatingRequestMatcherRegistered : public AllocatingRequestMatcherBase {
+class Server::AllocatingRequestMatcherRegistered
+    : public AllocatingRequestMatcherBase {
  public:
   AllocatingRequestMatcherRegistered(
-      grpc_server* server, grpc_completion_queue* cq, registered_method* rm,
-      std::function<grpc_core::ServerRegisteredCallAllocation()> allocator)
+      Server* server, grpc_completion_queue* cq, RegisteredMethod* rm,
+      std::function<RegisteredCallAllocation()> allocator)
       : AllocatingRequestMatcherBase(server, cq),
         registered_method_(rm),
         allocator_(std::move(allocator)) {}
+
   void MatchOrQueue(size_t /*start_request_queue_index*/,
-                    call_data* calld) override {
-    grpc_core::ServerRegisteredCallAllocation call_info = allocator_();
-    GPR_ASSERT(ValidateServerRequest(cq(), static_cast<void*>(call_info.tag),
-                                     call_info.optional_payload,
-                                     registered_method_) == GRPC_CALL_OK);
-    requested_call* rc = new requested_call(
-        static_cast<void*>(call_info.tag), cq(), call_info.call,
-        call_info.initial_metadata, registered_method_, call_info.deadline,
-        call_info.optional_payload);
-    gpr_atm_no_barrier_store(&calld->state, ACTIVATED);
-    publish_call(server(), calld, cq_idx(), rc);
+                    CallData* calld) override {
+    if (server()->ShutdownRefOnRequest()) {
+      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);
+      calld->SetState(CallData::CallState::ACTIVATED);
+      calld->Publish(cq_idx(), rc);
+    } else {
+      calld->FailCallCreation();
+    }
+    server()->ShutdownUnrefOnRequest();
   }
 
  private:
-  registered_method* const registered_method_;
-  std::function<grpc_core::ServerRegisteredCallAllocation()> allocator_;
+  RegisteredMethod* const registered_method_;
+  std::function<RegisteredCallAllocation()> allocator_;
 };
 
-/*
- * server proper
- */
-
-void server_ref(grpc_server* server) { server->internal_refcount.Ref(); }
-
-void server_delete(grpc_server* server) {
-  registered_method* rm;
-  size_t i;
-  server->channelz_server.reset();
-  grpc_channel_args_destroy(server->channel_args);
-  gpr_mu_destroy(&server->mu_global);
-  gpr_mu_destroy(&server->mu_call);
-  gpr_cv_destroy(&server->starting_cv);
-  while ((rm = server->registered_methods) != nullptr) {
-    server->registered_methods = rm->next;
-    delete rm;
-  }
-  delete server->unregistered_request_matcher;
-  for (i = 0; i < server->cq_count; i++) {
-    GRPC_CQ_INTERNAL_UNREF(server->cqs[i], "server");
-  }
-  gpr_free(server->cqs);
-  gpr_free(server->pollsets);
-  gpr_free(server->shutdown_tags);
-  gpr_free(server);
-}
-
-void server_unref(grpc_server* server) {
-  if (GPR_UNLIKELY(server->internal_refcount.Unref())) {
-    server_delete(server);
-  }
-}
-
-int is_channel_orphaned(channel_data* chand) { return chand->next == chand; }
-
-void orphan_channel(channel_data* chand) {
-  chand->next->prev = chand->prev;
-  chand->prev->next = chand->next;
-  chand->next = chand->prev = chand;
-}
+//
+// ChannelBroadcaster
+//
 
-void finish_destroy_channel(void* cd, grpc_error* /*error*/) {
-  channel_data* chand = static_cast<channel_data*>(cd);
-  grpc_server* server = chand->server;
-  GRPC_CHANNEL_INTERNAL_UNREF(chand->channel, "server");
-  server_unref(server);
-}
+namespace {
 
-void destroy_channel(channel_data* chand) {
-  if (is_channel_orphaned(chand)) return;
-  GPR_ASSERT(chand->server != nullptr);
-  orphan_channel(chand);
-  server_ref(chand->server);
-  maybe_finish_shutdown(chand->server);
-  GRPC_CLOSURE_INIT(&chand->finish_destroy_channel_closure,
-                    finish_destroy_channel, chand, grpc_schedule_on_exec_ctx);
+class ChannelBroadcaster {
+ public:
+  // This can have an empty constructor and destructor since we want to control
+  // when the actual setup and shutdown broadcast take place.
 
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_server_channel_trace)) {
-    gpr_log(GPR_INFO, "Disconnected client");
+  // Copies over the channels from the locked server.
+  void FillChannelsLocked(std::vector<grpc_channel*> channels) {
+    GPR_DEBUG_ASSERT(channels_.empty());
+    channels_ = std::move(channels);
   }
 
-  grpc_transport_op* op =
-      grpc_make_transport_op(&chand->finish_destroy_channel_closure);
-  op->set_accept_stream = true;
-  grpc_channel_next_op(grpc_channel_stack_element(
-                           grpc_channel_get_channel_stack(chand->channel), 0),
-                       op);
-}
-
-void done_request_event(void* req, grpc_cq_completion* /*c*/) {
-  delete static_cast<requested_call*>(req);
-}
-
-void publish_call(grpc_server* server, call_data* calld, size_t cq_idx,
-                  requested_call* rc) {
-  grpc_call_set_completion_queue(calld->call, rc->cq_bound_to_call);
-  grpc_call* call = calld->call;
-  *rc->call = call;
-  calld->cq_new = server->cqs[cq_idx];
-  GPR_SWAP(grpc_metadata_array, *rc->initial_metadata, calld->initial_metadata);
-  switch (rc->type) {
-    case BATCH_CALL:
-      GPR_ASSERT(calld->host_set);
-      GPR_ASSERT(calld->path_set);
-      rc->data.batch.details->host = grpc_slice_ref_internal(calld->host);
-      rc->data.batch.details->method = grpc_slice_ref_internal(calld->path);
-      rc->data.batch.details->deadline =
-          grpc_millis_to_timespec(calld->deadline, GPR_CLOCK_MONOTONIC);
-      rc->data.batch.details->flags = calld->recv_initial_metadata_flags;
-      break;
-    case REGISTERED_CALL:
-      *rc->data.registered.deadline =
-          grpc_millis_to_timespec(calld->deadline, GPR_CLOCK_MONOTONIC);
-      if (rc->data.registered.optional_payload) {
-        *rc->data.registered.optional_payload = calld->payload;
-        calld->payload = nullptr;
-      }
-      break;
-    default:
-      GPR_UNREACHABLE_CODE(return );
+  // 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");
+    }
+    channels_.clear();  // just for safety against double broadcast
+    GRPC_ERROR_UNREF(force_disconnect);
   }
 
-  grpc_cq_end_op(calld->cq_new, rc->tag, GRPC_ERROR_NONE, done_request_event,
-                 rc, &rc->completion, true);
-}
+ private:
+  struct ShutdownCleanupArgs {
+    grpc_closure closure;
+    grpc_slice slice;
+  };
 
-void publish_new_rpc(void* arg, grpc_error* error) {
-  grpc_call_element* call_elem = static_cast<grpc_call_element*>(arg);
-  call_data* calld = static_cast<call_data*>(call_elem->call_data);
-  channel_data* chand = static_cast<channel_data*>(call_elem->channel_data);
-  RequestMatcherInterface* rm = calld->matcher;
-  grpc_server* server = rm->server();
-
-  if (error != GRPC_ERROR_NONE || gpr_atm_acq_load(&server->shutdown_flag)) {
-    gpr_atm_no_barrier_store(&calld->state, ZOMBIED);
-    GRPC_CLOSURE_INIT(
-        &calld->kill_zombie_closure, kill_zombie,
-        grpc_call_stack_element(grpc_call_get_call_stack(calld->call), 0),
-        grpc_schedule_on_exec_ctx);
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, &calld->kill_zombie_closure,
-                            GRPC_ERROR_REF(error));
-    return;
+  static void ShutdownCleanup(void* arg, grpc_error_handle /*error*/) {
+    ShutdownCleanupArgs* a = static_cast<ShutdownCleanupArgs*>(arg);
+    grpc_slice_unref_internal(a->slice);
+    delete a;
   }
 
-  rm->MatchOrQueue(chand->cq_idx, calld);
-}
+  static void SendShutdown(grpc_channel* channel, bool send_goaway,
+                           grpc_error_handle send_disconnect) {
+    ShutdownCleanupArgs* sc = new ShutdownCleanupArgs;
+    GRPC_CLOSURE_INIT(&sc->closure, ShutdownCleanup, sc,
+                      grpc_schedule_on_exec_ctx);
+    grpc_transport_op* op = grpc_make_transport_op(&sc->closure);
+    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;
+    sc->slice = grpc_slice_from_copied_string("Server shutdown");
+    op->disconnect_with_error = send_disconnect;
+    elem =
+        grpc_channel_stack_element(grpc_channel_get_channel_stack(channel), 0);
+    elem->filter->start_transport_op(elem, op);
+  }
+
+  std::vector<grpc_channel*> channels_;
+};
+
+}  // namespace
 
-void finish_start_new_rpc(
-    grpc_server* server, grpc_call_element* elem, RequestMatcherInterface* rm,
-    grpc_server_register_method_payload_handling payload_handling) {
-  call_data* calld = static_cast<call_data*>(elem->call_data);
+//
+// Server
+//
 
-  if (gpr_atm_acq_load(&server->shutdown_flag)) {
-    gpr_atm_no_barrier_store(&calld->state, ZOMBIED);
-    GRPC_CLOSURE_INIT(&calld->kill_zombie_closure, kill_zombie, elem,
-                      grpc_schedule_on_exec_ctx);
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, &calld->kill_zombie_closure,
-                            GRPC_ERROR_NONE);
-    return;
-  }
+const grpc_channel_filter Server::kServerTopFilter = {
+    Server::CallData::StartTransportStreamOpBatch,
+    nullptr,
+    grpc_channel_next_op,
+    sizeof(Server::CallData),
+    Server::CallData::InitCallElement,
+    grpc_call_stack_ignore_set_pollset_or_pollset_set,
+    Server::CallData::DestroyCallElement,
+    sizeof(Server::ChannelData),
+    Server::ChannelData::InitChannelElement,
+    Server::ChannelData::DestroyChannelElement,
+    grpc_channel_next_get_info,
+    "server",
+};
 
-  calld->matcher = rm;
+namespace {
 
-  switch (payload_handling) {
-    case GRPC_SRM_PAYLOAD_NONE:
-      publish_new_rpc(elem, GRPC_ERROR_NONE);
-      break;
-    case GRPC_SRM_PAYLOAD_READ_INITIAL_BYTE_BUFFER: {
-      grpc_op op;
-      op.op = GRPC_OP_RECV_MESSAGE;
-      op.flags = 0;
-      op.reserved = nullptr;
-      op.data.recv_message.recv_message = &calld->payload;
-      GRPC_CLOSURE_INIT(&calld->publish, publish_new_rpc, elem,
-                        grpc_schedule_on_exec_ctx);
-      grpc_call_start_batch_and_execute(calld->call, &op, 1, &calld->publish);
-      break;
-    }
+RefCountedPtr<channelz::ServerNode> CreateChannelzNode(
+    const grpc_channel_args* 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});
+    channelz_node =
+        MakeRefCounted<channelz::ServerNode>(channel_tracer_max_memory);
+    channelz_node->AddTraceEvent(
+        channelz::ChannelTrace::Severity::Info,
+        grpc_slice_from_static_string("Server created"));
   }
+  return channelz_node;
 }
 
-void start_new_rpc(grpc_call_element* elem) {
-  channel_data* chand = static_cast<channel_data*>(elem->channel_data);
-  call_data* calld = static_cast<call_data*>(elem->call_data);
-  grpc_server* server = chand->server;
-  uint32_t i;
-  uint32_t hash;
-  channel_registered_method* rm;
-
-  if (chand->registered_methods && calld->path_set && calld->host_set) {
-    /* TODO(ctiller): unify these two searches */
-    /* check for an exact match with host */
-    hash = GRPC_MDSTR_KV_HASH(grpc_slice_hash_internal(calld->host),
-                              grpc_slice_hash_internal(calld->path));
-    for (i = 0; i <= chand->registered_method_max_probes; i++) {
-      rm = &chand->registered_methods[(hash + i) %
-                                      chand->registered_method_slots];
-      if (rm->server_registered_method == nullptr) break;
-      if (!rm->has_host) continue;
-      if (rm->host != calld->host) continue;
-      if (rm->method != calld->path) continue;
-      if ((rm->flags & GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST) &&
-          0 == (calld->recv_initial_metadata_flags &
-                GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST)) {
-        continue;
-      }
-      finish_start_new_rpc(server, elem,
-                           rm->server_registered_method->matcher.get(),
-                           rm->server_registered_method->payload_handling);
-      return;
-    }
-    /* check for a wildcard method definition (no host set) */
-    hash = GRPC_MDSTR_KV_HASH(0, grpc_slice_hash_internal(calld->path));
-    for (i = 0; i <= chand->registered_method_max_probes; i++) {
-      rm = &chand->registered_methods[(hash + i) %
-                                      chand->registered_method_slots];
-      if (rm->server_registered_method == nullptr) break;
-      if (rm->has_host) continue;
-      if (rm->method != calld->path) continue;
-      if ((rm->flags & GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST) &&
-          0 == (calld->recv_initial_metadata_flags &
-                GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST)) {
-        continue;
-      }
-      finish_start_new_rpc(server, elem,
-                           rm->server_registered_method->matcher.get(),
-                           rm->server_registered_method->payload_handling);
-      return;
+}  // namespace
+
+Server::Server(const grpc_channel_args* args)
+    : channel_args_(grpc_channel_args_copy(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) {
+    for (grpc_pollset* pollset : pollsets_) {
+      grpc_pollset_set_del_pollset(config_fetcher_->interested_parties(),
+                                   pollset);
     }
   }
-  finish_start_new_rpc(server, elem, server->unregistered_request_matcher,
-                       GRPC_SRM_PAYLOAD_NONE);
-}
-
-int num_listeners(grpc_server* server) {
-  listener* l;
-  int n = 0;
-  for (l = server->listeners; l; l = l->next) {
-    n++;
+  for (size_t i = 0; i < cqs_.size(); i++) {
+    GRPC_CQ_INTERNAL_UNREF(cqs_[i], "server");
   }
-  return n;
-}
-
-void done_shutdown_event(void* server, grpc_cq_completion* /*completion*/) {
-  server_unref(static_cast<grpc_server*>(server));
 }
 
-int num_channels(grpc_server* server) {
-  channel_data* chand;
-  int n = 0;
-  for (chand = server->root_channel_data.next;
-       chand != &server->root_channel_data; chand = chand->next) {
-    n++;
+void Server::AddListener(OrphanablePtr<ListenerInterface> listener) {
+  channelz::ListenSocketNode* listen_socket_node =
+      listener->channelz_listen_socket_node();
+  if (listen_socket_node != nullptr && channelz_node_ != nullptr) {
+    channelz_node_->AddChildListenSocket(listen_socket_node->Ref());
   }
-  return n;
+  listeners_.emplace_back(std::move(listener));
 }
 
-void kill_pending_work_locked(grpc_server* server, grpc_error* error) {
-  if (server->started) {
-    server->unregistered_request_matcher->KillRequests(GRPC_ERROR_REF(error));
-    server->unregistered_request_matcher->ZombifyPending();
-    for (registered_method* rm = server->registered_methods; rm;
-         rm = rm->next) {
-      rm->matcher->KillRequests(GRPC_ERROR_REF(error));
-      rm->matcher->ZombifyPending();
+void Server::Start() {
+  started_ = true;
+  for (grpc_completion_queue* cq : cqs_) {
+    if (grpc_cq_can_listen(cq)) {
+      pollsets_.push_back(grpc_cq_pollset(cq));
     }
   }
-  GRPC_ERROR_UNREF(error);
-}
-
-void maybe_finish_shutdown(grpc_server* server) {
-  size_t i;
-  if (!gpr_atm_acq_load(&server->shutdown_flag) || server->shutdown_published) {
-    return;
+  if (unregistered_request_matcher_ == nullptr) {
+    unregistered_request_matcher_ = absl::make_unique<RealRequestMatcher>(this);
   }
-
-  gpr_mu_lock(&server->mu_call);
-  kill_pending_work_locked(
-      server, GRPC_ERROR_CREATE_FROM_STATIC_STRING("Server Shutdown"));
-  gpr_mu_unlock(&server->mu_call);
-
-  if (server->root_channel_data.next != &server->root_channel_data ||
-      server->listeners_destroyed < num_listeners(server)) {
-    if (gpr_time_cmp(gpr_time_sub(gpr_now(GPR_CLOCK_REALTIME),
-                                  server->last_shutdown_message_time),
-                     gpr_time_from_seconds(1, GPR_TIMESPAN)) >= 0) {
-      server->last_shutdown_message_time = gpr_now(GPR_CLOCK_REALTIME);
-      gpr_log(GPR_DEBUG,
-              "Waiting for %d channels and %d/%d listeners to be destroyed"
-              " before shutting down server",
-              num_channels(server),
-              num_listeners(server) - server->listeners_destroyed,
-              num_listeners(server));
+  for (std::unique_ptr<RegisteredMethod>& rm : registered_methods_) {
+    if (rm->matcher == nullptr) {
+      rm->matcher = absl::make_unique<RealRequestMatcher>(this);
+    }
+  }
+  {
+    MutexLock lock(&mu_global_);
+    starting_ = true;
+  }
+  // Register the interested parties from the config fetcher to the cq pollsets
+  // before starting listeners so that config fetcher is being polled when the
+  // listeners start watch the fetcher.
+  if (config_fetcher_ != nullptr &&
+      config_fetcher_->interested_parties() != nullptr) {
+    for (grpc_pollset* pollset : pollsets_) {
+      grpc_pollset_set_add_pollset(config_fetcher_->interested_parties(),
+                                   pollset);
     }
-    return;
   }
-  server->shutdown_published = 1;
-  for (i = 0; i < server->num_shutdown_tags; i++) {
-    server_ref(server);
-    grpc_cq_end_op(server->shutdown_tags[i].cq, server->shutdown_tags[i].tag,
-                   GRPC_ERROR_NONE, done_shutdown_event, server,
-                   &server->shutdown_tags[i].completion);
+  for (auto& listener : listeners_) {
+    listener.listener->Start(this, &pollsets_);
   }
+  MutexLock lock(&mu_global_);
+  starting_ = false;
+  starting_cv_.Signal();
 }
 
-void server_on_recv_initial_metadata(void* ptr, grpc_error* error) {
-  grpc_call_element* elem = static_cast<grpc_call_element*>(ptr);
-  call_data* calld = static_cast<call_data*>(elem->call_data);
-  grpc_millis op_deadline;
-
-  if (error == GRPC_ERROR_NONE) {
-    GPR_DEBUG_ASSERT(calld->recv_initial_metadata->idx.named.path != nullptr);
-    GPR_DEBUG_ASSERT(calld->recv_initial_metadata->idx.named.authority !=
-                     nullptr);
-    calld->path = grpc_slice_ref_internal(
-        GRPC_MDVALUE(calld->recv_initial_metadata->idx.named.path->md));
-    calld->host = grpc_slice_ref_internal(
-        GRPC_MDVALUE(calld->recv_initial_metadata->idx.named.authority->md));
-    calld->path_set = true;
-    calld->host_set = true;
-    grpc_metadata_batch_remove(calld->recv_initial_metadata, GRPC_BATCH_PATH);
-    grpc_metadata_batch_remove(calld->recv_initial_metadata,
-                               GRPC_BATCH_AUTHORITY);
-  } else {
-    GRPC_ERROR_REF(error);
+grpc_error_handle Server::SetupTransport(
+    grpc_transport* transport, grpc_pollset* accepting_pollset,
+    const grpc_channel_args* 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;
   }
-  op_deadline = calld->recv_initial_metadata->deadline;
-  if (op_deadline != GRPC_MILLIS_INF_FUTURE) {
-    calld->deadline = op_deadline;
+  ChannelData* chand = static_cast<ChannelData*>(
+      grpc_channel_stack_element(grpc_channel_get_channel_stack(channel), 0)
+          ->channel_data);
+  // Set up CQs.
+  size_t cq_idx;
+  for (cq_idx = 0; cq_idx < cqs_.size(); cq_idx++) {
+    if (grpc_cq_pollset(cqs_[cq_idx]) == accepting_pollset) break;
   }
-  if (calld->host_set && calld->path_set) {
-    /* do nothing */
-  } else {
-    /* Pass the error reference to calld->recv_initial_metadata_error */
-    grpc_error* 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);
+  if (cq_idx == cqs_.size()) {
+    // Completion queue not found.  Pick a random one to publish new calls to.
+    cq_idx = static_cast<size_t>(rand()) % cqs_.size();
   }
-  grpc_closure* closure = calld->on_done_recv_initial_metadata;
-  calld->on_done_recv_initial_metadata = nullptr;
-  if (calld->seen_recv_trailing_metadata_ready) {
-    GRPC_CALL_COMBINER_START(calld->call_combiner,
-                             &calld->recv_trailing_metadata_ready,
-                             calld->recv_trailing_metadata_error,
-                             "continue server_recv_trailing_metadata_ready");
+  // Set up channelz node.
+  intptr_t channelz_socket_uuid = 0;
+  if (socket_node != nullptr) {
+    channelz_socket_uuid = socket_node->uuid();
+    channelz_node_->AddChildSocket(socket_node);
   }
-  grpc_core::Closure::Run(DEBUG_LOCATION, closure, error);
+  // Initialize chand.
+  chand->InitTransport(Ref(), channel, cq_idx, transport, channelz_socket_uuid);
+  return GRPC_ERROR_NONE;
 }
 
-void server_recv_trailing_metadata_ready(void* user_data, grpc_error* error) {
-  grpc_call_element* elem = static_cast<grpc_call_element*>(user_data);
-  call_data* calld = static_cast<call_data*>(elem->call_data);
-  if (calld->on_done_recv_initial_metadata != nullptr) {
-    calld->recv_trailing_metadata_error = GRPC_ERROR_REF(error);
-    calld->seen_recv_trailing_metadata_ready = true;
-    GRPC_CLOSURE_INIT(&calld->recv_trailing_metadata_ready,
-                      server_recv_trailing_metadata_ready, elem,
-                      grpc_schedule_on_exec_ctx);
-    GRPC_CALL_COMBINER_STOP(calld->call_combiner,
-                            "deferring server_recv_trailing_metadata_ready "
-                            "until after server_on_recv_initial_metadata");
-    return;
-  }
-  error =
-      grpc_error_add_child(GRPC_ERROR_REF(error),
-                           GRPC_ERROR_REF(calld->recv_initial_metadata_error));
-  grpc_core::Closure::Run(DEBUG_LOCATION,
-                          calld->original_recv_trailing_metadata_ready, error);
+bool Server::HasOpenConnections() {
+  MutexLock lock(&mu_global_);
+  return !channels_.empty();
 }
 
-void server_mutate_op(grpc_call_element* elem,
-                      grpc_transport_stream_op_batch* op) {
-  call_data* calld = static_cast<call_data*>(elem->call_data);
-
-  if (op->recv_initial_metadata) {
-    GPR_ASSERT(op->payload->recv_initial_metadata.recv_flags == nullptr);
-    calld->recv_initial_metadata =
-        op->payload->recv_initial_metadata.recv_initial_metadata;
-    calld->on_done_recv_initial_metadata =
-        op->payload->recv_initial_metadata.recv_initial_metadata_ready;
-    op->payload->recv_initial_metadata.recv_initial_metadata_ready =
-        &calld->server_on_recv_initial_metadata;
-    op->payload->recv_initial_metadata.recv_flags =
-        &calld->recv_initial_metadata_flags;
-  }
-  if (op->recv_trailing_metadata) {
-    calld->original_recv_trailing_metadata_ready =
-        op->payload->recv_trailing_metadata.recv_trailing_metadata_ready;
-    op->payload->recv_trailing_metadata.recv_trailing_metadata_ready =
-        &calld->recv_trailing_metadata_ready;
-  }
+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>(
+      this, cq, rm, std::move(allocator));
 }
 
-void server_start_transport_stream_op_batch(
-    grpc_call_element* elem, grpc_transport_stream_op_batch* op) {
-  server_mutate_op(elem, op);
-  grpc_call_next_op(elem, op);
+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));
 }
 
-void got_initial_metadata(void* ptr, grpc_error* error) {
-  grpc_call_element* elem = static_cast<grpc_call_element*>(ptr);
-  call_data* calld = static_cast<call_data*>(elem->call_data);
-  if (error == GRPC_ERROR_NONE) {
-    start_new_rpc(elem);
-  } else {
-    if (gpr_atm_full_cas(&calld->state, NOT_STARTED, ZOMBIED)) {
-      GRPC_CLOSURE_INIT(&calld->kill_zombie_closure, kill_zombie, elem,
-                        grpc_schedule_on_exec_ctx);
-      grpc_core::ExecCtx::Run(DEBUG_LOCATION, &calld->kill_zombie_closure,
-                              GRPC_ERROR_NONE);
-    } else if (gpr_atm_full_cas(&calld->state, PENDING, ZOMBIED)) {
-      /* zombied call will be destroyed when it's removed from the pending
-         queue... later */
-    }
+void Server::RegisterCompletionQueue(grpc_completion_queue* cq) {
+  for (grpc_completion_queue* queue : cqs_) {
+    if (queue == cq) return;
   }
+  GRPC_CQ_INTERNAL_REF(cq, "server");
+  cqs_.push_back(cq);
 }
 
-void accept_stream(void* cd, grpc_transport* /*transport*/,
-                   const void* transport_server_data) {
-  channel_data* chand = static_cast<channel_data*>(cd);
-  /* create a call */
-  grpc_call_create_args args;
-  args.channel = chand->channel;
-  args.server = chand->server;
-  args.parent = nullptr;
-  args.propagation_mask = 0;
-  args.cq = nullptr;
-  args.pollset_set_alternative = nullptr;
-  args.server_transport_data = transport_server_data;
-  args.add_initial_metadata = nullptr;
-  args.add_initial_metadata_count = 0;
-  args.send_deadline = GRPC_MILLIS_INF_FUTURE;
-  grpc_call* call;
-  grpc_error* error = grpc_call_create(&args, &call);
-  grpc_call_element* elem =
-      grpc_call_stack_element(grpc_call_get_call_stack(call), 0);
-  if (error != GRPC_ERROR_NONE) {
-    got_initial_metadata(elem, error);
-    GRPC_ERROR_UNREF(error);
-    return;
-  }
-  call_data* calld = static_cast<call_data*>(elem->call_data);
-  grpc_op op;
-  op.op = GRPC_OP_RECV_INITIAL_METADATA;
-  op.flags = 0;
-  op.reserved = nullptr;
-  op.data.recv_initial_metadata.recv_initial_metadata =
-      &calld->initial_metadata;
-  GRPC_CLOSURE_INIT(&calld->got_initial_metadata, got_initial_metadata, elem,
-                    grpc_schedule_on_exec_ctx);
-  grpc_call_start_batch_and_execute(call, &op, 1, &calld->got_initial_metadata);
+namespace {
+
+bool streq(const std::string& a, const char* b) {
+  return (a.empty() && b == nullptr) ||
+         ((b != nullptr) && !strcmp(a.c_str(), b));
 }
 
-grpc_error* server_init_call_elem(grpc_call_element* elem,
-                                  const grpc_call_element_args* args) {
-  channel_data* chand = static_cast<channel_data*>(elem->channel_data);
-  server_ref(chand->server);
-  new (elem->call_data) call_data(elem, *args);
-  return GRPC_ERROR_NONE;
+}  // namespace
+
+Server::RegisteredMethod* Server::RegisterMethod(
+    const char* method, const char* host,
+    grpc_server_register_method_payload_handling payload_handling,
+    uint32_t flags) {
+  if (!method) {
+    gpr_log(GPR_ERROR,
+            "grpc_server_register_method method string cannot be NULL");
+    return nullptr;
+  }
+  for (std::unique_ptr<RegisteredMethod>& m : registered_methods_) {
+    if (streq(m->method, method) && streq(m->host, host)) {
+      gpr_log(GPR_ERROR, "duplicate registration for %s@%s", method,
+              host ? host : "*");
+      return nullptr;
+    }
+  }
+  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>(
+      method, host, payload_handling, flags));
+  return registered_methods_.back().get();
 }
 
-void server_destroy_call_elem(grpc_call_element* elem,
-                              const grpc_call_final_info* /*final_info*/,
-                              grpc_closure* /*ignored*/) {
-  call_data* calld = static_cast<call_data*>(elem->call_data);
-  calld->~call_data();
-  channel_data* chand = static_cast<channel_data*>(elem->channel_data);
-  server_unref(chand->server);
+void Server::DoneRequestEvent(void* req, grpc_cq_completion* /*c*/) {
+  delete static_cast<RequestedCall*>(req);
 }
 
-grpc_error* server_init_channel_elem(grpc_channel_element* elem,
-                                     grpc_channel_element_args* args) {
-  channel_data* chand = static_cast<channel_data*>(elem->channel_data);
-  GPR_ASSERT(args->is_first);
-  GPR_ASSERT(!args->is_last);
-  chand->server = nullptr;
-  chand->channel = nullptr;
-  chand->next = chand->prev = chand;
-  chand->registered_methods = nullptr;
-  return GRPC_ERROR_NONE;
+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);
+  grpc_cq_end_op(cqs_[cq_idx], rc->tag, error, DoneRequestEvent, rc,
+                 &rc->completion);
 }
 
-void server_destroy_channel_elem(grpc_channel_element* elem) {
-  size_t i;
-  channel_data* chand = static_cast<channel_data*>(elem->channel_data);
-  if (chand->registered_methods) {
-    for (i = 0; i < chand->registered_method_slots; i++) {
-      grpc_slice_unref_internal(chand->registered_methods[i].method);
-      GPR_DEBUG_ASSERT(chand->registered_methods[i].method.refcount ==
-                           &grpc_core::kNoopRefcount ||
-                       chand->registered_methods[i].method.refcount == nullptr);
-      if (chand->registered_methods[i].has_host) {
-        grpc_slice_unref_internal(chand->registered_methods[i].host);
-        GPR_DEBUG_ASSERT(chand->registered_methods[i].host.refcount ==
-                             &grpc_core::kNoopRefcount ||
-                         chand->registered_methods[i].host.refcount == nullptr);
-      }
+// Before calling MaybeFinishShutdown(), we must hold mu_global_ and not
+// hold mu_call_.
+void Server::MaybeFinishShutdown() {
+  if (!ShutdownReady() || shutdown_published_) {
+    return;
+  }
+  {
+    MutexLock lock(&mu_call_);
+    KillPendingWorkLocked(
+        GRPC_ERROR_CREATE_FROM_STATIC_STRING("Server Shutdown"));
+  }
+  if (!channels_.empty() || listeners_destroyed_ < listeners_.size()) {
+    if (gpr_time_cmp(gpr_time_sub(gpr_now(GPR_CLOCK_REALTIME),
+                                  last_shutdown_message_time_),
+                     gpr_time_from_seconds(1, GPR_TIMESPAN)) >= 0) {
+      last_shutdown_message_time_ = gpr_now(GPR_CLOCK_REALTIME);
+      gpr_log(GPR_DEBUG,
+              "Waiting for %" PRIuPTR " channels and %" PRIuPTR "/%" PRIuPTR
+              " listeners to be destroyed before shutting down server",
+              channels_.size(), listeners_.size() - listeners_destroyed_,
+              listeners_.size());
     }
-    gpr_free(chand->registered_methods);
+    return;
+  }
+  shutdown_published_ = true;
+  for (auto& shutdown_tag : shutdown_tags_) {
+    Ref().release();
+    grpc_cq_end_op(shutdown_tag.cq, shutdown_tag.tag, GRPC_ERROR_NONE,
+                   DoneShutdownEvent, this, &shutdown_tag.completion);
   }
-  if (chand->server) {
-    if (chand->server->channelz_server != nullptr &&
-        chand->channelz_socket_uuid != 0) {
-      chand->server->channelz_server->RemoveChildSocket(
-          chand->channelz_socket_uuid);
+}
+
+void Server::KillPendingWorkLocked(grpc_error_handle error) {
+  if (started_) {
+    unregistered_request_matcher_->KillRequests(GRPC_ERROR_REF(error));
+    unregistered_request_matcher_->ZombifyPending();
+    for (std::unique_ptr<RegisteredMethod>& rm : registered_methods_) {
+      rm->matcher->KillRequests(GRPC_ERROR_REF(error));
+      rm->matcher->ZombifyPending();
     }
-    gpr_mu_lock(&chand->server->mu_global);
-    chand->next->prev = chand->prev;
-    chand->prev->next = chand->next;
-    chand->next = chand->prev = chand;
-    maybe_finish_shutdown(chand->server);
-    gpr_mu_unlock(&chand->server->mu_global);
-    server_unref(chand->server);
   }
+  GRPC_ERROR_UNREF(error);
 }
 
-void register_completion_queue(grpc_server* server, grpc_completion_queue* cq,
-                               void* reserved) {
-  size_t i, n;
-  GPR_ASSERT(!reserved);
-  for (i = 0; i < server->cq_count; i++) {
-    if (server->cqs[i] == cq) return;
+std::vector<grpc_channel*> Server::GetChannelsLocked() const {
+  std::vector<grpc_channel*> channels;
+  channels.reserve(channels_.size());
+  for (const ChannelData* chand : channels_) {
+    channels.push_back(chand->channel());
+    GRPC_CHANNEL_INTERNAL_REF(chand->channel(), "broadcast");
   }
+  return channels;
+}
 
-  GRPC_CQ_INTERNAL_REF(cq, "server");
-  n = server->cq_count++;
-  server->cqs = static_cast<grpc_completion_queue**>(gpr_realloc(
-      server->cqs, server->cq_count * sizeof(grpc_completion_queue*)));
-  server->cqs[n] = cq;
+void Server::ListenerDestroyDone(void* arg, grpc_error_handle /*error*/) {
+  Server* server = static_cast<Server*>(arg);
+  MutexLock lock(&server->mu_global_);
+  server->listeners_destroyed_++;
+  server->MaybeFinishShutdown();
 }
 
-bool streq(const std::string& a, const char* b) {
-  return (a.empty() && b == nullptr) ||
-         ((b != nullptr) && !strcmp(a.c_str(), b));
+namespace {
+
+void DonePublishedShutdown(void* /*done_arg*/, grpc_cq_completion* storage) {
+  delete storage;
 }
 
-class ConnectivityWatcher
-    : public grpc_core::AsyncConnectivityStateWatcherInterface {
- public:
-  explicit ConnectivityWatcher(channel_data* chand) : chand_(chand) {
-    GRPC_CHANNEL_INTERNAL_REF(chand_->channel, "connectivity");
-  }
+}  // namespace
 
-  ~ConnectivityWatcher() {
-    GRPC_CHANNEL_INTERNAL_UNREF(chand_->channel, "connectivity");
+// - Kills all pending requests-for-incoming-RPC-calls (i.e., the requests made
+//   via grpc_server_request_call() and grpc_server_request_registered_call()
+//   will now be cancelled). See KillPendingWorkLocked().
+//
+// - Shuts down the listeners (i.e., the server will no longer listen on the
+//   port for new incoming channels).
+//
+// - Iterates through all channels on the server and sends shutdown msg (see
+//   ChannelBroadcaster::BroadcastShutdown() for details) to the clients via
+//   the transport layer. The transport layer then guarantees the following:
+//    -- Sends shutdown to the client (e.g., HTTP2 transport sends GOAWAY).
+//    -- If the server has outstanding calls that are in the process, the
+//       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;
+  ChannelBroadcaster broadcaster;
+  {
+    // Wait for startup to be finished.  Locks mu_global.
+    MutexLock lock(&mu_global_);
+    while (starting_) {
+      starting_cv_.Wait(&mu_global_);
+    }
+    // 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,
+                     new grpc_cq_completion);
+      return;
+    }
+    shutdown_tags_.emplace_back(tag, cq);
+    if (ShutdownCalled()) {
+      return;
+    }
+    last_shutdown_message_time_ = gpr_now(GPR_CLOCK_REALTIME);
+    broadcaster.FillChannelsLocked(GetChannelsLocked());
+    // Collect all unregistered then registered calls.
+    {
+      MutexLock lock(&mu_call_);
+      KillPendingWorkLocked(
+          GRPC_ERROR_CREATE_FROM_STATIC_STRING("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();
+  }
+  // Shutdown listeners.
+  for (auto& listener : listeners_) {
+    channelz::ListenSocketNode* channelz_listen_socket_node =
+        listener.listener->channelz_listen_socket_node();
+    if (channelz_node_ != nullptr && channelz_listen_socket_node != nullptr) {
+      channelz_node_->RemoveChildListenSocket(
+          channelz_listen_socket_node->uuid());
+    }
+    GRPC_CLOSURE_INIT(&listener.destroy_done, ListenerDestroyDone, this,
+                      grpc_schedule_on_exec_ctx);
+    listener.listener->SetOnDestroyDone(&listener.destroy_done);
+    listener.listener.reset();
   }
+  broadcaster.BroadcastShutdown(/*send_goaway=*/true, GRPC_ERROR_NONE);
+}
 
- private:
-  void OnConnectivityStateChange(grpc_connectivity_state new_state) override {
-    // Don't do anything until we are being shut down.
-    if (new_state != GRPC_CHANNEL_SHUTDOWN) return;
-    // Shut down channel.
-    grpc_server* server = chand_->server;
-    gpr_mu_lock(&server->mu_global);
-    destroy_channel(chand_);
-    gpr_mu_unlock(&server->mu_global);
+void Server::CancelAllCalls() {
+  ChannelBroadcaster broadcaster;
+  {
+    MutexLock lock(&mu_global_);
+    broadcaster.FillChannelsLocked(GetChannelsLocked());
   }
+  broadcaster.BroadcastShutdown(
+      /*send_goaway=*/false,
+      GRPC_ERROR_CREATE_FROM_STATIC_STRING("Cancelling all calls"));
+}
 
-  channel_data* chand_;
-};
+void Server::Orphan() {
+  {
+    MutexLock lock(&mu_global_);
+    GPR_ASSERT(ShutdownCalled() || listeners_.empty());
+    GPR_ASSERT(listeners_destroyed_ == listeners_.size());
+  }
+  Unref();
+}
 
-void done_published_shutdown(void* done_arg, grpc_cq_completion* storage) {
-  (void)done_arg;
-  gpr_free(storage);
+grpc_call_error Server::ValidateServerRequest(
+    grpc_completion_queue* cq_for_notification, void* tag,
+    grpc_byte_buffer** optional_payload, RegisteredMethod* rm) {
+  if ((rm == nullptr && optional_payload != nullptr) ||
+      ((rm != nullptr) && ((optional_payload == nullptr) !=
+                           (rm->payload_handling == GRPC_SRM_PAYLOAD_NONE)))) {
+    return GRPC_CALL_ERROR_PAYLOAD_TYPE_MISMATCH;
+  }
+  if (!grpc_cq_begin_op(cq_for_notification, tag)) {
+    return GRPC_CALL_ERROR_COMPLETION_QUEUE_SHUTDOWN;
+  }
+  return GRPC_CALL_OK;
 }
 
-void listener_destroy_done(void* s, grpc_error* /*error*/) {
-  grpc_server* server = static_cast<grpc_server*>(s);
-  gpr_mu_lock(&server->mu_global);
-  server->listeners_destroyed++;
-  maybe_finish_shutdown(server);
-  gpr_mu_unlock(&server->mu_global);
+grpc_call_error Server::ValidateServerRequestAndCq(
+    size_t* cq_idx, grpc_completion_queue* cq_for_notification, void* tag,
+    grpc_byte_buffer** optional_payload, RegisteredMethod* rm) {
+  size_t idx;
+  for (idx = 0; idx < cqs_.size(); idx++) {
+    if (cqs_[idx] == cq_for_notification) {
+      break;
+    }
+  }
+  if (idx == cqs_.size()) {
+    return GRPC_CALL_ERROR_NOT_SERVER_COMPLETION_QUEUE;
+  }
+  grpc_call_error error =
+      ValidateServerRequest(cq_for_notification, tag, optional_payload, rm);
+  if (error != GRPC_CALL_OK) {
+    return error;
+  }
+  *cq_idx = idx;
+  return GRPC_CALL_OK;
 }
 
-grpc_call_error queue_call_request(grpc_server* server, size_t cq_idx,
-                                   requested_call* rc) {
-  if (gpr_atm_acq_load(&server->shutdown_flag)) {
-    fail_call(server, cq_idx, rc,
-              GRPC_ERROR_CREATE_FROM_STATIC_STRING("Server Shutdown"));
+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"));
     return GRPC_CALL_OK;
   }
   RequestMatcherInterface* rm;
   switch (rc->type) {
-    case BATCH_CALL:
-      rm = server->unregistered_request_matcher;
+    case RequestedCall::Type::BATCH_CALL:
+      rm = unregistered_request_matcher_.get();
       break;
-    case REGISTERED_CALL:
+    case RequestedCall::Type::REGISTERED_CALL:
       rm = rc->data.registered.method->matcher.get();
       break;
   }
@@ -1243,482 +915,598 @@ grpc_call_error queue_call_request(grpc_server* server, size_t cq_idx,
   return GRPC_CALL_OK;
 }
 
-void fail_call(grpc_server* server, size_t cq_idx, requested_call* rc,
-               grpc_error* error) {
-  *rc->call = nullptr;
-  rc->initial_metadata->count = 0;
-  GPR_ASSERT(error != GRPC_ERROR_NONE);
-
-  grpc_cq_end_op(server->cqs[cq_idx], rc->tag, error, done_request_event, rc,
-                 &rc->completion);
-}
-}  // namespace
-
-namespace grpc_core {
-
-void SetServerRegisteredMethodAllocator(
-    grpc_server* server, grpc_completion_queue* cq, void* method_tag,
-    std::function<ServerRegisteredCallAllocation()> allocator) {
-  registered_method* rm = static_cast<registered_method*>(method_tag);
-  rm->matcher.reset(new AllocatingRequestMatcherRegistered(
-      server, cq, rm, std::move(allocator)));
-}
-
-void SetServerBatchMethodAllocator(
-    grpc_server* server, grpc_completion_queue* cq,
-    std::function<ServerBatchCallAllocation()> allocator) {
-  GPR_DEBUG_ASSERT(server->unregistered_request_matcher == nullptr);
-  server->unregistered_request_matcher =
-      new AllocatingRequestMatcherBatch(server, cq, std::move(allocator));
+grpc_call_error Server::RequestCall(grpc_call** call,
+                                    grpc_call_details* details,
+                                    grpc_metadata_array* request_metadata,
+                                    grpc_completion_queue* cq_bound_to_call,
+                                    grpc_completion_queue* cq_for_notification,
+                                    void* tag) {
+  size_t cq_idx;
+  grpc_call_error error = ValidateServerRequestAndCq(
+      &cq_idx, cq_for_notification, tag, nullptr, nullptr);
+  if (error != GRPC_CALL_OK) {
+    return error;
+  }
+  RequestedCall* rc =
+      new RequestedCall(tag, cq_bound_to_call, call, request_metadata, details);
+  return QueueRequestedCall(cq_idx, rc);
 }
 
-};  // namespace grpc_core
-
-const grpc_channel_filter grpc_server_top_filter = {
-    server_start_transport_stream_op_batch,
-    grpc_channel_next_op,
-    sizeof(call_data),
-    server_init_call_elem,
-    grpc_call_stack_ignore_set_pollset_or_pollset_set,
-    server_destroy_call_elem,
-    sizeof(channel_data),
-    server_init_channel_elem,
-    server_destroy_channel_elem,
-    grpc_channel_next_get_info,
-    "server",
-};
-
-void grpc_server_register_completion_queue(grpc_server* server,
-                                           grpc_completion_queue* cq,
-                                           void* reserved) {
-  GRPC_API_TRACE(
-      "grpc_server_register_completion_queue(server=%p, cq=%p, reserved=%p)", 3,
-      (server, cq, reserved));
-
-  auto cq_type = grpc_get_cq_completion_type(cq);
-  if (cq_type != GRPC_CQ_NEXT && cq_type != GRPC_CQ_CALLBACK) {
-    gpr_log(GPR_INFO,
-            "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 */
+grpc_call_error Server::RequestRegisteredCall(
+    RegisteredMethod* rm, grpc_call** call, gpr_timespec* deadline,
+    grpc_metadata_array* request_metadata, grpc_byte_buffer** optional_payload,
+    grpc_completion_queue* cq_bound_to_call,
+    grpc_completion_queue* cq_for_notification, void* tag_new) {
+  size_t cq_idx;
+  grpc_call_error error = ValidateServerRequestAndCq(
+      &cq_idx, cq_for_notification, tag_new, optional_payload, rm);
+  if (error != GRPC_CALL_OK) {
+    return error;
   }
-
-  register_completion_queue(server, cq, reserved);
+  RequestedCall* rc =
+      new RequestedCall(tag_new, cq_bound_to_call, call, request_metadata, rm,
+                        deadline, optional_payload);
+  return QueueRequestedCall(cq_idx, rc);
 }
 
-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));
-
-  grpc_server* server =
-      static_cast<grpc_server*>(gpr_zalloc(sizeof(grpc_server)));
-
-  gpr_mu_init(&server->mu_global);
-  gpr_mu_init(&server->mu_call);
-  gpr_cv_init(&server->starting_cv);
-
-  /* decremented by grpc_server_destroy */
-  new (&server->internal_refcount) grpc_core::RefCount();
-  server->root_channel_data.next = server->root_channel_data.prev =
-      &server->root_channel_data;
-
-  server->channel_args = grpc_channel_args_copy(args);
+//
+// Server::ChannelData::ConnectivityWatcher
+//
 
-  const grpc_arg* arg = grpc_channel_args_find(args, GRPC_ARG_ENABLE_CHANNELZ);
-  if (grpc_channel_arg_get_bool(arg, GRPC_ENABLE_CHANNELZ_DEFAULT)) {
-    arg = grpc_channel_args_find(
-        args, GRPC_ARG_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE);
-    size_t channel_tracer_max_memory = grpc_channel_arg_get_integer(
-        arg,
-        {GRPC_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE_DEFAULT, 0, INT_MAX});
-    server->channelz_server =
-        grpc_core::MakeRefCounted<grpc_core::channelz::ServerNode>(
-            server, channel_tracer_max_memory);
-    server->channelz_server->AddTraceEvent(
-        grpc_core::channelz::ChannelTrace::Severity::Info,
-        grpc_slice_from_static_string("Server created"));
+class Server::ChannelData::ConnectivityWatcher
+    : public AsyncConnectivityStateWatcherInterface {
+ public:
+  explicit ConnectivityWatcher(ChannelData* chand) : chand_(chand) {
+    GRPC_CHANNEL_INTERNAL_REF(chand_->channel_, "connectivity");
   }
 
-  if (args != nullptr) {
-    grpc_resource_quota* resource_quota =
-        grpc_resource_quota_from_channel_args(args, false /* create */);
-    if (resource_quota != nullptr) {
-      server->default_resource_user =
-          grpc_resource_user_create(resource_quota, "default");
-    }
+  ~ConnectivityWatcher() override {
+    GRPC_CHANNEL_INTERNAL_UNREF(chand_->channel_, "connectivity");
   }
 
-  return server;
-}
-
-void* grpc_server_register_method(
-    grpc_server* server, const char* method, const char* host,
-    grpc_server_register_method_payload_handling payload_handling,
-    uint32_t flags) {
-  registered_method* m;
-  GRPC_API_TRACE(
-      "grpc_server_register_method(server=%p, method=%s, host=%s, "
-      "flags=0x%08x)",
-      4, (server, method, host, flags));
-  if (!method) {
-    gpr_log(GPR_ERROR,
-            "grpc_server_register_method method string cannot be NULL");
-    return nullptr;
-  }
-  for (m = server->registered_methods; m; m = m->next) {
-    if (streq(m->method, method) && streq(m->host, host)) {
-      gpr_log(GPR_ERROR, "duplicate registration for %s@%s", method,
-              host ? host : "*");
-      return nullptr;
-    }
-  }
-  if ((flags & ~GRPC_INITIAL_METADATA_USED_MASK) != 0) {
-    gpr_log(GPR_ERROR, "grpc_server_register_method invalid flags 0x%08x",
-            flags);
-    return nullptr;
+ private:
+  void OnConnectivityStateChange(grpc_connectivity_state new_state,
+                                 const absl::Status& /*status*/) override {
+    // Don't do anything until we are being shut down.
+    if (new_state != GRPC_CHANNEL_SHUTDOWN) return;
+    // Shut down channel.
+    MutexLock lock(&chand_->server_->mu_global_);
+    chand_->Destroy();
   }
-  m = new registered_method(method, host, payload_handling, flags);
-  m->next = server->registered_methods;
-  server->registered_methods = m;
-  return m;
-}
 
-void grpc_server_start(grpc_server* server) {
-  size_t i;
-  grpc_core::ExecCtx exec_ctx;
+  ChannelData* chand_;
+};
 
-  GRPC_API_TRACE("grpc_server_start(server=%p)", 1, (server));
+//
+// Server::ChannelData
+//
 
-  server->started = true;
-  server->pollset_count = 0;
-  server->pollsets = static_cast<grpc_pollset**>(
-      gpr_malloc(sizeof(grpc_pollset*) * server->cq_count));
-  for (i = 0; i < server->cq_count; i++) {
-    if (grpc_cq_can_listen(server->cqs[i])) {
-      server->pollsets[server->pollset_count++] =
-          grpc_cq_pollset(server->cqs[i]);
+Server::ChannelData::~ChannelData() {
+  registered_methods_.reset();
+  if (server_ != nullptr) {
+    if (server_->channelz_node_ != nullptr && channelz_socket_uuid_ != 0) {
+      server_->channelz_node_->RemoveChildSocket(channelz_socket_uuid_);
     }
-  }
-  if (server->unregistered_request_matcher == nullptr) {
-    server->unregistered_request_matcher = new RealRequestMatcher(server);
-  }
-  for (registered_method* rm = server->registered_methods; rm; rm = rm->next) {
-    if (rm->matcher == nullptr) {
-      rm->matcher.reset(new RealRequestMatcher(server));
+    {
+      MutexLock lock(&server_->mu_global_);
+      if (list_position_.has_value()) {
+        server_->channels_.erase(*list_position_);
+        list_position_.reset();
+      }
+      server_->MaybeFinishShutdown();
     }
   }
-
-  gpr_mu_lock(&server->mu_global);
-  server->starting = true;
-  gpr_mu_unlock(&server->mu_global);
-
-  for (listener* l = server->listeners; l; l = l->next) {
-    l->start(server, l->arg, server->pollsets, server->pollset_count);
-  }
-
-  gpr_mu_lock(&server->mu_global);
-  server->starting = false;
-  gpr_cv_signal(&server->starting_cv);
-  gpr_mu_unlock(&server->mu_global);
-}
-
-void grpc_server_get_pollsets(grpc_server* server, grpc_pollset*** pollsets,
-                              size_t* pollset_count) {
-  *pollset_count = server->pollset_count;
-  *pollsets = server->pollsets;
 }
 
-void grpc_server_setup_transport(
-    grpc_server* s, grpc_transport* transport, grpc_pollset* accepting_pollset,
-    const grpc_channel_args* args,
-    const grpc_core::RefCountedPtr<grpc_core::channelz::SocketNode>&
-        socket_node,
-    grpc_resource_user* resource_user) {
-  size_t num_registered_methods;
-  size_t alloc;
-  registered_method* rm;
-  channel_registered_method* crm;
-  grpc_channel* channel;
-  channel_data* chand;
-  uint32_t hash;
-  size_t slots;
-  uint32_t probes;
-  uint32_t max_probes = 0;
-  grpc_transport_op* op = nullptr;
-
-  channel = grpc_channel_create(nullptr, args, GRPC_SERVER_CHANNEL, transport,
-                                resource_user);
-  chand = static_cast<channel_data*>(
-      grpc_channel_stack_element(grpc_channel_get_channel_stack(channel), 0)
-          ->channel_data);
-  chand->server = s;
-  server_ref(s);
-  chand->channel = channel;
-  if (socket_node != nullptr) {
-    chand->channelz_socket_uuid = socket_node->uuid();
-    s->channelz_server->AddChildSocket(socket_node);
-  } else {
-    chand->channelz_socket_uuid = 0;
-  }
-
-  size_t cq_idx;
-  for (cq_idx = 0; cq_idx < s->cq_count; cq_idx++) {
-    if (grpc_cq_pollset(s->cqs[cq_idx]) == accepting_pollset) break;
-  }
-  if (cq_idx == s->cq_count) {
-    /* completion queue not found: pick a random one to publish new calls to */
-    cq_idx = static_cast<size_t>(rand()) % s->cq_count;
-  }
-  chand->cq_idx = cq_idx;
-
-  num_registered_methods = 0;
-  for (rm = s->registered_methods; rm; rm = rm->next) {
-    num_registered_methods++;
-  }
-  /* build a lookup table phrased in terms of mdstr's in this channels context
-     to quickly find registered methods */
+void Server::ChannelData::InitTransport(RefCountedPtr<Server> server,
+                                        grpc_channel* channel, size_t cq_idx,
+                                        grpc_transport* transport,
+                                        intptr_t channelz_socket_uuid) {
+  server_ = std::move(server);
+  channel_ = channel;
+  cq_idx_ = cq_idx;
+  channelz_socket_uuid_ = channelz_socket_uuid;
+  // Build a lookup table phrased in terms of mdstr's in this channels context
+  // to quickly find registered methods.
+  size_t num_registered_methods = server_->registered_methods_.size();
   if (num_registered_methods > 0) {
-    slots = 2 * num_registered_methods;
-    alloc = sizeof(channel_registered_method) * slots;
-    chand->registered_methods =
-        static_cast<channel_registered_method*>(gpr_zalloc(alloc));
-    for (rm = s->registered_methods; rm; rm = rm->next) {
-      grpc_core::ExternallyManagedSlice host;
-      grpc_core::ExternallyManagedSlice method(rm->method.c_str());
+    uint32_t max_probes = 0;
+    size_t slots = 2 * num_registered_methods;
+    registered_methods_ =
+        absl::make_unique<std::vector<ChannelRegisteredMethod>>(slots);
+    for (std::unique_ptr<RegisteredMethod>& rm : server_->registered_methods_) {
+      Slice host;
+      Slice method = Slice::FromExternalString(rm->method);
       const bool has_host = !rm->host.empty();
       if (has_host) {
-        host = grpc_core::ExternallyManagedSlice(rm->host.c_str());
+        host = Slice::FromExternalString(rm->host.c_str());
       }
-      hash = GRPC_MDSTR_KV_HASH(has_host ? host.Hash() : 0, method.Hash());
-      for (probes = 0; chand->registered_methods[(hash + probes) % slots]
+      uint32_t hash = MixHash32(has_host ? host.Hash() : 0, method.Hash());
+      uint32_t probes = 0;
+      for (probes = 0; (*registered_methods_)[(hash + probes) % slots]
                            .server_registered_method != nullptr;
-           probes++)
-        ;
+           probes++) {
+      }
       if (probes > max_probes) max_probes = probes;
-      crm = &chand->registered_methods[(hash + probes) % slots];
-      crm->server_registered_method = rm;
+      ChannelRegisteredMethod* crm =
+          &(*registered_methods_)[(hash + probes) % slots];
+      crm->server_registered_method = rm.get();
       crm->flags = rm->flags;
       crm->has_host = has_host;
       if (has_host) {
-        crm->host = host;
+        crm->host = std::move(host);
       }
-      crm->method = method;
+      crm->method = std::move(method);
     }
     GPR_ASSERT(slots <= UINT32_MAX);
-    chand->registered_method_slots = static_cast<uint32_t>(slots);
-    chand->registered_method_max_probes = max_probes;
+    registered_method_max_probes_ = max_probes;
   }
-
-  gpr_mu_lock(&s->mu_global);
-  chand->next = &s->root_channel_data;
-  chand->prev = chand->next->prev;
-  chand->next->prev = chand->prev->next = chand;
-  gpr_mu_unlock(&s->mu_global);
-
-  op = grpc_make_transport_op(nullptr);
+  // Publish channel.
+  {
+    MutexLock lock(&server_->mu_global_);
+    server_->channels_.push_front(this);
+    list_position_ = server_->channels_.begin();
+  }
+  // Start accept_stream transport op.
+  grpc_transport_op* op = grpc_make_transport_op(nullptr);
   op->set_accept_stream = true;
-  op->set_accept_stream_fn = accept_stream;
-  op->set_accept_stream_user_data = chand;
-  op->start_connectivity_watch.reset(new ConnectivityWatcher(chand));
-  if (gpr_atm_acq_load(&s->shutdown_flag) != 0) {
+  op->set_accept_stream_fn = AcceptStream;
+  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");
   }
   grpc_transport_perform_op(transport, op);
 }
 
-/*
-  - Kills all pending requests-for-incoming-RPC-calls (i.e the requests made via
-    grpc_server_request_call and grpc_server_request_registered call will now be
-    cancelled). See 'kill_pending_work_locked()'
-
-  - Shuts down the listeners (i.e the server will no longer listen on the port
-    for new incoming channels).
-
-  - Iterates through all channels on the server and sends shutdown msg (see
-    'channel_broadcaster_shutdown()' for details) to the clients via the
-    transport layer. The transport layer then guarantees the following:
-     -- Sends shutdown to the client (for eg: HTTP2 transport sends GOAWAY)
-     -- If the server has outstanding calls that are in the process, the
-        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 grpc_server_shutdown_and_notify(grpc_server* server,
-                                     grpc_completion_queue* cq, void* tag) {
-  listener* l;
-  shutdown_tag* sdt;
-  channel_broadcaster broadcaster;
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
-  grpc_core::ExecCtx exec_ctx;
+Server::ChannelRegisteredMethod* Server::ChannelData::GetRegisteredMethod(
+    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));
+  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->host != host) continue;
+    if (rm->method != path) continue;
+    return rm;
+  }
+  /* check for a wildcard method definition (no host set) */
+  hash = MixHash32(0, grpc_slice_hash_internal(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;
+    return rm;
+  }
+  return nullptr;
+}
 
-  GRPC_API_TRACE("grpc_server_shutdown_and_notify(server=%p, cq=%p, tag=%p)", 3,
-                 (server, cq, tag));
+void Server::ChannelData::AcceptStream(void* arg, grpc_transport* /*transport*/,
+                                       const void* transport_server_data) {
+  auto* chand = static_cast<Server::ChannelData*>(arg);
+  /* create a call */
+  grpc_call_create_args args;
+  args.channel = chand->channel_;
+  args.server = chand->server_.get();
+  args.parent = nullptr;
+  args.propagation_mask = 0;
+  args.cq = nullptr;
+  args.pollset_set_alternative = nullptr;
+  args.server_transport_data = transport_server_data;
+  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();
+    return;
+  }
+  calld->Start(elem);
+}
+
+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");
+  server->Unref();
+}
 
-  /* wait for startup to be finished: locks mu_global */
-  gpr_mu_lock(&server->mu_global);
-  while (server->starting) {
-    gpr_cv_wait(&server->starting_cv, &server->mu_global,
-                gpr_inf_future(GPR_CLOCK_MONOTONIC));
+void Server::ChannelData::Destroy() {
+  if (!list_position_.has_value()) return;
+  GPR_ASSERT(server_ != nullptr);
+  server_->channels_.erase(*list_position_);
+  list_position_.reset();
+  server_->Ref().release();
+  server_->MaybeFinishShutdown();
+  GRPC_CLOSURE_INIT(&finish_destroy_channel_closure_, FinishDestroy, this,
+                    grpc_schedule_on_exec_ctx);
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_server_channel_trace)) {
+    gpr_log(GPR_INFO, "Disconnected client");
   }
+  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);
+}
 
-  /* stay locked, and gather up some stuff to do */
-  GPR_ASSERT(grpc_cq_begin_op(cq, tag));
-  if (server->shutdown_published) {
-    grpc_cq_end_op(cq, tag, GRPC_ERROR_NONE, done_published_shutdown, nullptr,
-                   static_cast<grpc_cq_completion*>(
-                       gpr_malloc(sizeof(grpc_cq_completion))));
-    gpr_mu_unlock(&server->mu_global);
-    return;
+grpc_error_handle Server::ChannelData::InitChannelElement(
+    grpc_channel_element* elem, grpc_channel_element_args* args) {
+  GPR_ASSERT(args->is_first);
+  GPR_ASSERT(!args->is_last);
+  new (elem->channel_data) ChannelData();
+  return GRPC_ERROR_NONE;
+}
+
+void Server::ChannelData::DestroyChannelElement(grpc_channel_element* elem) {
+  auto* chand = static_cast<ChannelData*>(elem->channel_data);
+  chand->~ChannelData();
+}
+
+//
+// Server::CallData
+//
+
+Server::CallData::CallData(grpc_call_element* elem,
+                           const grpc_call_element_args& args,
+                           RefCountedPtr<Server> server)
+    : server_(std::move(server)),
+      call_(grpc_call_from_top_element(elem)),
+      call_combiner_(args.call_combiner) {
+  GRPC_CLOSURE_INIT(&recv_initial_metadata_ready_, RecvInitialMetadataReady,
+                    elem, grpc_schedule_on_exec_ctx);
+  GRPC_CLOSURE_INIT(&recv_trailing_metadata_ready_, RecvTrailingMetadataReady,
+                    elem, grpc_schedule_on_exec_ctx);
+}
+
+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_);
+}
+
+void Server::CallData::SetState(CallState state) {
+  state_.store(state, std::memory_order_relaxed);
+}
+
+bool Server::CallData::MaybeActivate() {
+  CallState expected = CallState::PENDING;
+  return state_.compare_exchange_strong(expected, CallState::ACTIVATED,
+                                        std::memory_order_acq_rel,
+                                        std::memory_order_relaxed);
+}
+
+void Server::CallData::FailCallCreation() {
+  CallState expected_not_started = CallState::NOT_STARTED;
+  CallState expected_pending = CallState::PENDING;
+  if (state_.compare_exchange_strong(expected_not_started, CallState::ZOMBIED,
+                                     std::memory_order_acq_rel,
+                                     std::memory_order_acquire)) {
+    KillZombie();
+  } else if (state_.compare_exchange_strong(
+                 expected_pending, CallState::ZOMBIED,
+                 std::memory_order_acq_rel, std::memory_order_relaxed)) {
+    // Zombied call will be destroyed when it's removed from the pending
+    // queue... later.
   }
-  server->shutdown_tags = static_cast<shutdown_tag*>(
-      gpr_realloc(server->shutdown_tags,
-                  sizeof(shutdown_tag) * (server->num_shutdown_tags + 1)));
-  sdt = &server->shutdown_tags[server->num_shutdown_tags++];
-  sdt->tag = tag;
-  sdt->cq = cq;
-  if (gpr_atm_acq_load(&server->shutdown_flag)) {
-    gpr_mu_unlock(&server->mu_global);
-    return;
+}
+
+void Server::CallData::Start(grpc_call_element* elem) {
+  grpc_op op;
+  op.op = GRPC_OP_RECV_INITIAL_METADATA;
+  op.flags = 0;
+  op.reserved = nullptr;
+  op.data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_;
+  GRPC_CLOSURE_INIT(&recv_initial_metadata_batch_complete_,
+                    RecvInitialMetadataBatchComplete, elem,
+                    grpc_schedule_on_exec_ctx);
+  grpc_call_start_batch_and_execute(call_, &op, 1,
+                                    &recv_initial_metadata_batch_complete_);
+}
+
+void Server::CallData::Publish(size_t cq_idx, RequestedCall* rc) {
+  grpc_call_set_completion_queue(call_, rc->cq_bound_to_call);
+  *rc->call = call_;
+  cq_new_ = server_->cqs_[cq_idx];
+  std::swap(*rc->initial_metadata, initial_metadata_);
+  switch (rc->type) {
+    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->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 =
+          deadline_.as_timespec(GPR_CLOCK_MONOTONIC);
+      if (rc->data.registered.optional_payload != nullptr) {
+        *rc->data.registered.optional_payload = payload_;
+        payload_ = nullptr;
+      }
+      break;
+    default:
+      GPR_UNREACHABLE_CODE(return );
   }
+  grpc_cq_end_op(cq_new_, rc->tag, GRPC_ERROR_NONE, Server::DoneRequestEvent,
+                 rc, &rc->completion, true);
+}
 
-  server->last_shutdown_message_time = gpr_now(GPR_CLOCK_REALTIME);
+void Server::CallData::PublishNewRpc(void* arg, grpc_error_handle error) {
+  grpc_call_element* call_elem = static_cast<grpc_call_element*>(arg);
+  auto* calld = static_cast<Server::CallData*>(call_elem->call_data);
+  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()) {
+    calld->state_.store(CallState::ZOMBIED, std::memory_order_relaxed);
+    calld->KillZombie();
+    return;
+  }
+  rm->MatchOrQueue(chand->cq_idx(), calld);
+}
 
-  channel_broadcaster_init(server, &broadcaster);
+namespace {
 
-  gpr_atm_rel_store(&server->shutdown_flag, 1);
+void KillZombieClosure(void* call, grpc_error_handle /*error*/) {
+  grpc_call_unref(static_cast<grpc_call*>(call));
+}
 
-  /* collect all unregistered then registered calls */
-  gpr_mu_lock(&server->mu_call);
-  kill_pending_work_locked(
-      server, GRPC_ERROR_CREATE_FROM_STATIC_STRING("Server Shutdown"));
-  gpr_mu_unlock(&server->mu_call);
+}  // namespace
 
-  maybe_finish_shutdown(server);
-  gpr_mu_unlock(&server->mu_global);
+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);
+}
 
-  /* Shutdown listeners */
-  for (l = server->listeners; l; l = l->next) {
-    GRPC_CLOSURE_INIT(&l->destroy_done, listener_destroy_done, server,
-                      grpc_schedule_on_exec_ctx);
-    l->destroy(server, l->arg, &l->destroy_done);
-    if (server->channelz_server != nullptr && l->socket_uuid != 0) {
-      server->channelz_server->RemoveChildListenSocket(l->socket_uuid);
+void Server::CallData::StartNewRpc(grpc_call_element* elem) {
+  auto* chand = static_cast<ChannelData*>(elem->channel_data);
+  if (server_->ShutdownCalled()) {
+    state_.store(CallState::ZOMBIED, std::memory_order_relaxed);
+    KillZombie();
+    return;
+  }
+  // Find request matcher.
+  matcher_ = server_->unregistered_request_matcher_.get();
+  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());
+    if (rm != nullptr) {
+      matcher_ = rm->server_registered_method->matcher.get();
+      payload_handling = rm->server_registered_method->payload_handling;
     }
   }
+  // Start recv_message op if needed.
+  switch (payload_handling) {
+    case GRPC_SRM_PAYLOAD_NONE:
+      PublishNewRpc(elem, GRPC_ERROR_NONE);
+      break;
+    case GRPC_SRM_PAYLOAD_READ_INITIAL_BYTE_BUFFER: {
+      grpc_op op;
+      op.op = GRPC_OP_RECV_MESSAGE;
+      op.flags = 0;
+      op.reserved = nullptr;
+      op.data.recv_message.recv_message = &payload_;
+      GRPC_CLOSURE_INIT(&publish_, PublishNewRpc, elem,
+                        grpc_schedule_on_exec_ctx);
+      grpc_call_start_batch_and_execute(call_, &op, 1, &publish_);
+      break;
+    }
+  }
+}
 
-  channel_broadcaster_shutdown(&broadcaster, true /* send_goaway */,
-                               GRPC_ERROR_NONE);
+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) {
+    gpr_log(GPR_DEBUG, "Failed call creation: %s",
+            grpc_error_std_string(error).c_str());
+    calld->FailCallCreation();
+    return;
+  }
+  calld->StartNewRpc(elem);
+}
 
-  if (server->default_resource_user != nullptr) {
-    grpc_resource_quota_unref(
-        grpc_resource_user_quota(server->default_resource_user));
-    grpc_resource_user_shutdown(server->default_resource_user);
-    grpc_resource_user_unref(server->default_resource_user);
+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_ =
+        batch->payload->recv_trailing_metadata.recv_trailing_metadata_ready;
+    batch->payload->recv_trailing_metadata.recv_trailing_metadata_ready =
+        &recv_trailing_metadata_ready_;
+  }
+  grpc_call_next_op(elem, batch);
+}
+
+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) {
+    calld->path_ = calld->recv_initial_metadata_->Take(HttpPathMetadata());
+    calld->host_ = calld->recv_initial_metadata_->Take(HttpAuthorityMetadata());
+  } else {
+    (void)GRPC_ERROR_REF(error);
+  }
+  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);
   }
+  grpc_closure* closure = calld->original_recv_initial_metadata_ready_;
+  calld->original_recv_initial_metadata_ready_ = nullptr;
+  if (calld->seen_recv_trailing_metadata_ready_) {
+    GRPC_CALL_COMBINER_START(calld->call_combiner_,
+                             &calld->recv_trailing_metadata_ready_,
+                             calld->recv_trailing_metadata_error_,
+                             "continue server recv_trailing_metadata_ready");
+  }
+  Closure::Run(DEBUG_LOCATION, closure, error);
 }
 
-void grpc_server_cancel_all_calls(grpc_server* server) {
-  channel_broadcaster broadcaster;
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
-  grpc_core::ExecCtx exec_ctx;
+void Server::CallData::RecvTrailingMetadataReady(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 (calld->original_recv_initial_metadata_ready_ != nullptr) {
+    calld->recv_trailing_metadata_error_ = GRPC_ERROR_REF(error);
+    calld->seen_recv_trailing_metadata_ready_ = true;
+    GRPC_CLOSURE_INIT(&calld->recv_trailing_metadata_ready_,
+                      RecvTrailingMetadataReady, elem,
+                      grpc_schedule_on_exec_ctx);
+    GRPC_CALL_COMBINER_STOP(calld->call_combiner_,
+                            "deferring server recv_trailing_metadata_ready "
+                            "until after recv_initial_metadata_ready");
+    return;
+  }
+  error =
+      grpc_error_add_child(GRPC_ERROR_REF(error),
+                           GRPC_ERROR_REF(calld->recv_initial_metadata_error_));
+  Closure::Run(DEBUG_LOCATION, calld->original_recv_trailing_metadata_ready_,
+               error);
+}
 
-  GRPC_API_TRACE("grpc_server_cancel_all_calls(server=%p)", 1, (server));
+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;
+}
 
-  gpr_mu_lock(&server->mu_global);
-  channel_broadcaster_init(server, &broadcaster);
-  gpr_mu_unlock(&server->mu_global);
+void Server::CallData::DestroyCallElement(
+    grpc_call_element* elem, const grpc_call_final_info* /*final_info*/,
+    grpc_closure* /*ignored*/) {
+  auto* calld = static_cast<CallData*>(elem->call_data);
+  calld->~CallData();
+}
 
-  channel_broadcaster_shutdown(
-      &broadcaster, false /* send_goaway */,
-      GRPC_ERROR_CREATE_FROM_STATIC_STRING("Cancelling all calls"));
+void Server::CallData::StartTransportStreamOpBatch(
+    grpc_call_element* elem, grpc_transport_stream_op_batch* batch) {
+  auto* calld = static_cast<CallData*>(elem->call_data);
+  calld->StartTransportStreamOpBatchImpl(elem, batch);
 }
 
-void grpc_server_destroy(grpc_server* server) {
-  listener* l;
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
-  grpc_core::ExecCtx exec_ctx;
+}  // namespace grpc_core
 
-  GRPC_API_TRACE("grpc_server_destroy(server=%p)", 1, (server));
+//
+// C-core API
+//
 
-  gpr_mu_lock(&server->mu_global);
-  GPR_ASSERT(gpr_atm_acq_load(&server->shutdown_flag) || !server->listeners);
-  GPR_ASSERT(server->listeners_destroyed == num_listeners(server));
+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);
+  return server->c_ptr();
+}
 
-  while (server->listeners) {
-    l = server->listeners;
-    server->listeners = l->next;
-    gpr_free(l);
+void grpc_server_register_completion_queue(grpc_server* server,
+                                           grpc_completion_queue* cq,
+                                           void* reserved) {
+  GRPC_API_TRACE(
+      "grpc_server_register_completion_queue(server=%p, cq=%p, reserved=%p)", 3,
+      (server, cq, reserved));
+  GPR_ASSERT(!reserved);
+  auto cq_type = grpc_get_cq_completion_type(cq);
+  if (cq_type != GRPC_CQ_NEXT && cq_type != GRPC_CQ_CALLBACK) {
+    gpr_log(GPR_INFO,
+            "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 */
   }
+  grpc_core::Server::FromC(server)->RegisterCompletionQueue(cq);
+}
 
-  gpr_mu_unlock(&server->mu_global);
+void* grpc_server_register_method(
+    grpc_server* server, const char* method, const char* host,
+    grpc_server_register_method_payload_handling payload_handling,
+    uint32_t flags) {
+  GRPC_API_TRACE(
+      "grpc_server_register_method(server=%p, method=%s, host=%s, "
+      "flags=0x%08x)",
+      4, (server, method, host, flags));
+  return grpc_core::Server::FromC(server)->RegisterMethod(
+      method, host, payload_handling, flags);
+}
 
-  server_unref(server);
+void grpc_server_start(grpc_server* server) {
+  grpc_core::ExecCtx exec_ctx;
+  GRPC_API_TRACE("grpc_server_start(server=%p)", 1, (server));
+  grpc_core::Server::FromC(server)->Start();
 }
 
-void grpc_server_add_listener(
-    grpc_server* server, void* listener_arg,
-    void (*start)(grpc_server* server, void* arg, grpc_pollset** pollsets,
-                  size_t pollset_count),
-    void (*destroy)(grpc_server* server, void* arg, grpc_closure* on_done),
-    grpc_core::RefCountedPtr<grpc_core::channelz::ListenSocketNode> node) {
-  listener* l = static_cast<listener*>(gpr_malloc(sizeof(listener)));
-  l->arg = listener_arg;
-  l->start = start;
-  l->destroy = destroy;
-  l->socket_uuid = 0;
-  if (node != nullptr) {
-    l->socket_uuid = node->uuid();
-    if (server->channelz_server != nullptr) {
-      server->channelz_server->AddChildListenSocket(std::move(node));
-    }
-  }
-  l->next = server->listeners;
-  server->listeners = l;
+void grpc_server_shutdown_and_notify(grpc_server* server,
+                                     grpc_completion_queue* cq, void* tag) {
+  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
+  grpc_core::ExecCtx exec_ctx;
+  GRPC_API_TRACE("grpc_server_shutdown_and_notify(server=%p, cq=%p, tag=%p)", 3,
+                 (server, cq, tag));
+  grpc_core::Server::FromC(server)->ShutdownAndNotify(cq, tag);
 }
 
-namespace {
-grpc_call_error ValidateServerRequest(
-    grpc_completion_queue* cq_for_notification, void* tag,
-    grpc_byte_buffer** optional_payload, registered_method* rm) {
-  if ((rm == nullptr && optional_payload != nullptr) ||
-      ((rm != nullptr) && ((optional_payload == nullptr) !=
-                           (rm->payload_handling == GRPC_SRM_PAYLOAD_NONE)))) {
-    return GRPC_CALL_ERROR_PAYLOAD_TYPE_MISMATCH;
-  }
-  if (grpc_cq_begin_op(cq_for_notification, tag) == false) {
-    return GRPC_CALL_ERROR_COMPLETION_QUEUE_SHUTDOWN;
-  }
-  return GRPC_CALL_OK;
+void grpc_server_cancel_all_calls(grpc_server* server) {
+  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
+  grpc_core::ExecCtx exec_ctx;
+  GRPC_API_TRACE("grpc_server_cancel_all_calls(server=%p)", 1, (server));
+  grpc_core::Server::FromC(server)->CancelAllCalls();
 }
-grpc_call_error ValidateServerRequestAndCq(
-    size_t* cq_idx, grpc_server* server,
-    grpc_completion_queue* cq_for_notification, void* tag,
-    grpc_byte_buffer** optional_payload, registered_method* rm) {
-  size_t idx;
-  for (idx = 0; idx < server->cq_count; idx++) {
-    if (server->cqs[idx] == cq_for_notification) {
-      break;
-    }
-  }
-  if (idx == server->cq_count) {
-    return GRPC_CALL_ERROR_NOT_SERVER_COMPLETION_QUEUE;
-  }
-  grpc_call_error error =
-      ValidateServerRequest(cq_for_notification, tag, optional_payload, rm);
-  if (error != GRPC_CALL_OK) {
-    return error;
-  }
 
-  *cq_idx = idx;
-  return GRPC_CALL_OK;
+void grpc_server_destroy(grpc_server* server) {
+  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
+  grpc_core::ExecCtx exec_ctx;
+  GRPC_API_TRACE("grpc_server_destroy(server=%p)", 1, (server));
+  grpc_core::Server::FromC(server)->Orphan();
 }
-}  // namespace
 
 grpc_call_error grpc_server_request_call(
     grpc_server* server, grpc_call** call, grpc_call_details* details,
-    grpc_metadata_array* initial_metadata,
+    grpc_metadata_array* request_metadata,
     grpc_completion_queue* cq_bound_to_call,
     grpc_completion_queue* cq_for_notification, void* tag) {
   grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
@@ -1729,72 +1517,53 @@ grpc_call_error grpc_server_request_call(
       "server=%p, call=%p, details=%p, initial_metadata=%p, "
       "cq_bound_to_call=%p, cq_for_notification=%p, tag=%p)",
       7,
-      (server, call, details, initial_metadata, cq_bound_to_call,
+      (server, call, details, request_metadata, cq_bound_to_call,
        cq_for_notification, tag));
-
-  size_t cq_idx;
-  grpc_call_error error = ValidateServerRequestAndCq(
-      &cq_idx, server, cq_for_notification, tag, nullptr, nullptr);
-  if (error != GRPC_CALL_OK) {
-    return error;
-  }
-
-  requested_call* rc = new requested_call(tag, cq_bound_to_call, call,
-                                          initial_metadata, details);
-  return queue_call_request(server, cq_idx, rc);
+  return grpc_core::Server::FromC(server)->RequestCall(
+      call, details, request_metadata, cq_bound_to_call, cq_for_notification,
+      tag);
 }
 
 grpc_call_error grpc_server_request_registered_call(
-    grpc_server* server, void* rmp, grpc_call** call, gpr_timespec* deadline,
-    grpc_metadata_array* initial_metadata, grpc_byte_buffer** optional_payload,
+    grpc_server* server, void* registered_method, grpc_call** call,
+    gpr_timespec* deadline, grpc_metadata_array* request_metadata,
+    grpc_byte_buffer** optional_payload,
     grpc_completion_queue* cq_bound_to_call,
-    grpc_completion_queue* cq_for_notification, void* tag) {
+    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();
-  registered_method* rm = static_cast<registered_method*>(rmp);
+  auto* rm =
+      static_cast<grpc_core::Server::RegisteredMethod*>(registered_method);
   GRPC_API_TRACE(
       "grpc_server_request_registered_call("
-      "server=%p, rmp=%p, call=%p, deadline=%p, initial_metadata=%p, "
+      "server=%p, registered_method=%p, call=%p, deadline=%p, "
+      "request_metadata=%p, "
       "optional_payload=%p, cq_bound_to_call=%p, cq_for_notification=%p, "
       "tag=%p)",
       9,
-      (server, rmp, call, deadline, initial_metadata, optional_payload,
-       cq_bound_to_call, cq_for_notification, tag));
-
-  size_t cq_idx;
-  grpc_call_error error = ValidateServerRequestAndCq(
-      &cq_idx, server, cq_for_notification, tag, optional_payload, rm);
-  if (error != GRPC_CALL_OK) {
-    return error;
-  }
-
-  requested_call* rc =
-      new requested_call(tag, cq_bound_to_call, call, initial_metadata, rm,
-                         deadline, optional_payload);
-  return queue_call_request(server, cq_idx, rc);
-}
-
-const grpc_channel_args* grpc_server_get_channel_args(grpc_server* server) {
-  return server->channel_args;
-}
-
-grpc_resource_user* grpc_server_get_default_resource_user(grpc_server* server) {
-  return server->default_resource_user;
+      (server, registered_method, call, deadline, request_metadata,
+       optional_payload, cq_bound_to_call, cq_for_notification, tag_new));
+  return grpc_core::Server::FromC(server)->RequestRegisteredCall(
+      rm, call, deadline, request_metadata, optional_payload, cq_bound_to_call,
+      cq_for_notification, tag_new);
 }
 
-int grpc_server_has_open_connections(grpc_server* server) {
-  int r;
-  gpr_mu_lock(&server->mu_global);
-  r = server->root_channel_data.next != &server->root_channel_data;
-  gpr_mu_unlock(&server->mu_global);
-  return r;
+void grpc_server_set_config_fetcher(
+    grpc_server* server, grpc_server_config_fetcher* server_config_fetcher) {
+  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
+  grpc_core::ExecCtx exec_ctx;
+  GRPC_API_TRACE("grpc_server_set_config_fetcher(server=%p, config_fetcher=%p)",
+                 2, (server, server_config_fetcher));
+  grpc_core::Server::FromC(server)->set_config_fetcher(
+      std::unique_ptr<grpc_server_config_fetcher>(server_config_fetcher));
 }
 
-grpc_core::channelz::ServerNode* grpc_server_get_channelz_node(
-    grpc_server* server) {
-  if (server == nullptr) {
-    return nullptr;
-  }
-  return server->channelz_server.get();
+void grpc_server_config_fetcher_destroy(
+    grpc_server_config_fetcher* server_config_fetcher) {
+  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
+  grpc_core::ExecCtx exec_ctx;
+  GRPC_API_TRACE("grpc_server_config_fetcher_destroy(config_fetcher=%p)", 1,
+                 (server_config_fetcher));
+  delete server_config_fetcher;
 }