grpc 1.30.2 → 1.31.0.pre1

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

@@ -69,6 +69,14 @@ void grpc_cq_internal_unref(grpc_completion_queue* cc);
 /* Initializes global variables used by completion queues */
 void grpc_cq_global_init();
 
+// Completion queue initializations that must be done after iomgr
+// TODO(vjpai): Remove when callback_alternative is no longer needed.
+void grpc_cq_init();
+
+// Completion queue shutdowns that must be done before iomgr shutdown.
+// TODO(vjpai): Remove when callback_alternative is no longer needed.
+void grpc_cq_shutdown();
+
 /* Flag that an operation is beginning: the completion channel will not finish
    shutdown until a corrensponding grpc_cq_end_* call is made.
    \a tag is currently used only in debug builds. Return true on success, and

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

@@ -144,6 +144,7 @@ void grpc_init(void) {
     grpc_core::ApplicationCallbackExecCtx::GlobalInit();
     grpc_core::ExecCtx::GlobalInit();
     grpc_iomgr_init();
+    grpc_cq_init();
     gpr_timers_global_init();
     grpc_core::HandshakerRegistry::Init();
     grpc_security_init();
@@ -169,6 +170,7 @@ void grpc_shutdown_internal_locked(void) {
   int i;
   {
     grpc_core::ExecCtx exec_ctx(0);
+    grpc_cq_shutdown();
     grpc_iomgr_shutdown_background_closure();
     {
       grpc_timer_manager_set_threading(false);  // shutdown timer_manager thread

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

@@ -24,11 +24,18 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include <algorithm>
+#include <atomic>
+#include <iterator>
+#include <list>
+#include <utility>
+#include <vector>
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
-#include <utility>
+#include "absl/types/optional.h"
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channelz.h"
@@ -48,26 +55,24 @@
 #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");
+namespace grpc_core {
 
-using grpc_core::LockedMultiProducerSingleConsumerQueue;
+TraceFlag grpc_server_channel_trace(false, "server_channel");
 
 namespace {
 
 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;
+struct Listener {
+  explicit Listener(OrphanablePtr<ServerListenerInterface> l)
+      : listener(std::move(l)) {}
+
+  OrphanablePtr<ServerListenerInterface> listener;
   grpc_closure destroy_done;
 };
 
-enum requested_call_type { BATCH_CALL, REGISTERED_CALL };
+enum class RequestedCallType { BATCH_CALL, REGISTERED_CALL };
 
 struct registered_method;
 
@@ -75,7 +80,7 @@ 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),
+      : type(RequestedCallType::BATCH_CALL),
         tag(tag_arg),
         cq_bound_to_call(call_cq),
         call(call_arg),
@@ -88,7 +93,7 @@ struct requested_call {
                  grpc_call** call_arg, grpc_metadata_array* initial_md,
                  registered_method* rm, gpr_timespec* deadline,
                  grpc_byte_buffer** optional_payload)
-      : type(REGISTERED_CALL),
+      : type(RequestedCallType::REGISTERED_CALL),
         tag(tag_arg),
         cq_bound_to_call(call_cq),
         call(call_arg),
@@ -98,8 +103,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 RequestedCallType type;
   void* const tag;
   grpc_completion_queue* const cq_bound_to_call;
   grpc_call** const call;
@@ -118,34 +123,43 @@ struct requested_call {
 };
 
 struct channel_registered_method {
-  registered_method* server_registered_method;
+  registered_method* server_registered_method = nullptr;
   uint32_t flags;
   bool has_host;
-  grpc_core::ExternallyManagedSlice method;
-  grpc_core::ExternallyManagedSlice host;
+  ExternallyManagedSlice method;
+  ExternallyManagedSlice host;
 };
 
 struct channel_data {
-  grpc_server* server;
+  channel_data() = default;
+  ~channel_data();
+
+  grpc_server* server = nullptr;
   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;
+  absl::optional<std::list<channel_data*>::iterator> list_position;
+
+  // registered_methods is a hash-table of the methods and hosts of the
+  // registered methods.
+  // TODO(vjpai): Convert this to an STL map type as opposed to a direct bucket
+  // implementation. (Consider performance impact, hash function to use, etc.)
+  std::unique_ptr<std::vector<channel_registered_method>> registered_methods;
   uint32_t registered_method_max_probes;
+
   grpc_closure finish_destroy_channel_closure;
   intptr_t channelz_socket_uuid;
 };
 
 struct shutdown_tag {
-  void* tag;
-  grpc_completion_queue* cq;
+  shutdown_tag(void* tag_arg, grpc_completion_queue* cq_arg)
+      : tag(tag_arg), cq(cq_arg) {}
+
+  void* const tag;
+  grpc_completion_queue* const cq;
   grpc_cq_completion completion;
 };
 
-enum call_state {
+enum class CallState {
   /* waiting for metadata */
   NOT_STARTED,
   /* initial metadata read, not flow controlled in yet */
@@ -213,15 +227,16 @@ 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_CLOSURE_INIT(&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,
+                      server_recv_trailing_metadata_ready, elem,
                       grpc_schedule_on_exec_ctx);
   }
   ~call_data() {
-    GPR_ASSERT(state != PENDING);
+    GPR_ASSERT(state.Load(grpc_core::MemoryOrder::RELAXED) !=
+               CallState::PENDING);
     GRPC_ERROR_UNREF(recv_initial_metadata_error);
     if (host_set) {
       grpc_slice_unref_internal(host);
@@ -235,7 +250,7 @@ struct call_data {
 
   grpc_call* call;
 
-  gpr_atm state = NOT_STARTED;
+  Atomic<CallState> state{CallState::NOT_STARTED};
 
   bool path_set = false;
   bool host_set = false;
@@ -254,7 +269,7 @@ struct call_data {
   grpc_byte_buffer* payload = nullptr;
 
   grpc_closure got_initial_metadata;
-  grpc_closure server_on_recv_initial_metadata;
+  grpc_closure on_recv_initial_metadata;
   grpc_closure kill_zombie_closure;
   grpc_closure* on_done_recv_initial_metadata;
   grpc_closure recv_trailing_metadata_ready;
@@ -265,8 +280,7 @@ struct call_data {
 
   grpc_closure publish;
 
-  call_data* pending_next = nullptr;
-  grpc_core::CallCombiner* call_combiner;
+  CallCombiner* call_combiner;
 };
 
 struct registered_method {
@@ -287,25 +301,51 @@ struct registered_method {
   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
+}  // namespace grpc_core
 
 struct grpc_server {
-  grpc_channel_args* channel_args;
+  explicit grpc_server(const grpc_channel_args* args)
+      : channel_args(grpc_channel_args_copy(args)) {
+    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_server =
+          grpc_core::MakeRefCounted<grpc_core::channelz::ServerNode>(
+              this, channel_tracer_max_memory);
+      channelz_server->AddTraceEvent(
+          grpc_core::channelz::ChannelTrace::Severity::Info,
+          grpc_slice_from_static_string("Server created"));
+    }
 
-  grpc_resource_user* default_resource_user;
+    if (args != nullptr) {
+      grpc_resource_quota* resource_quota =
+          grpc_resource_quota_from_channel_args(args, false /* create */);
+      if (resource_quota != nullptr) {
+        default_resource_user =
+            grpc_resource_user_create(resource_quota, "default");
+      }
+    }
+  }
 
-  grpc_completion_queue** cqs;
-  grpc_pollset** pollsets;
-  size_t cq_count;
-  size_t pollset_count;
-  bool started;
+  ~grpc_server() {
+    grpc_channel_args_destroy(channel_args);
+    for (size_t i = 0; i < cqs.size(); i++) {
+      GRPC_CQ_INTERNAL_UNREF(cqs[i], "server");
+    }
+  }
+
+  grpc_channel_args* const channel_args;
+
+  grpc_resource_user* default_resource_user = nullptr;
+
+  std::vector<grpc_completion_queue*> cqs;
+  std::vector<grpc_pollset*> pollsets;
+  bool started = false;
 
   /* The two following mutexes control access to server-state
      mu_global controls access to non-call-related state (e.g., channel state)
@@ -314,31 +354,28 @@ struct grpc_server {
      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 */
+  grpc_core::Mutex mu_global;  // mutex for server and channel state
+  grpc_core::Mutex 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;
+  bool starting = false;
+  grpc_core::CondVar starting_cv;
+
+  std::vector<std::unique_ptr<grpc_core::registered_method>> registered_methods;
+
+  // one request matcher for unregistered methods
+  std::unique_ptr<grpc_core::RequestMatcherInterface>
+      unregistered_request_matcher;
+
+  std::atomic_bool shutdown_flag{false};
+  bool shutdown_published = false;
+  std::vector<grpc_core::shutdown_tag> shutdown_tags;
+
+  std::list<grpc_core::channel_data*> channels;
+
+  std::list<grpc_core::Listener> listeners;
+  size_t listeners_destroyed = 0;
   grpc_core::RefCount internal_refcount;
 
   /** when did we print the last shutdown progress message */
@@ -347,10 +384,43 @@ struct grpc_server {
   grpc_core::RefCountedPtr<grpc_core::channelz::ServerNode> channelz_server;
 };
 
-#define SERVER_FROM_CALL_ELEM(elem) \
-  (((channel_data*)(elem)->channel_data)->server)
+// Non-API functions of the server that are only for gRPC core internal use.
+// TODO(markdroth): Make these class member functions
+void grpc_server_add_listener(
+    grpc_server* server,
+    grpc_core::OrphanablePtr<grpc_core::ServerListenerInterface> listener) {
+  grpc_core::channelz::ListenSocketNode* listen_socket_node =
+      listener->channelz_listen_socket_node();
+  if (listen_socket_node != nullptr && server->channelz_server != nullptr) {
+    server->channelz_server->AddChildListenSocket(listen_socket_node->Ref());
+  }
+  server->listeners.emplace_back(std::move(listener));
+}
+
+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;
+}
+
+bool grpc_server_has_open_connections(grpc_server* server) {
+  grpc_core::MutexLock lock(&server->mu_global);
+  return !server->channels.empty();
+}
+
+grpc_core::channelz::ServerNode* grpc_server_get_channelz_node(
+    grpc_server* server) {
+  if (server == nullptr) {
+    return nullptr;
+  }
+  return server->channelz_server.get();
+}
 
+namespace grpc_core {
 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,
@@ -364,26 +434,47 @@ void kill_zombie(void* elem, grpc_error* /*error*/) {
       grpc_call_from_top_element(static_cast<grpc_call_element*>(elem)));
 }
 
-/*
- * channel broadcaster
- */
+// Validate a requested RPC for a server CQ and bind it to that CQ
+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;
+}
 
-/* 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");
+// Validate that a requested RPC has a valid server CQ and is valid, and bind it
+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->cqs.size(); idx++) {
+    if (server->cqs[idx] == cq_for_notification) {
+      break;
+    }
+  }
+  if (idx == server->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;
 }
+/*
+ * channel broadcaster
+ */
 
 struct shutdown_cleanup_args {
   grpc_closure closure;
@@ -391,16 +482,14 @@ struct shutdown_cleanup_args {
 };
 
 void shutdown_cleanup(void* arg, grpc_error* /*error*/) {
-  struct shutdown_cleanup_args* a =
-      static_cast<struct shutdown_cleanup_args*>(arg);
+  shutdown_cleanup_args* a = static_cast<shutdown_cleanup_args*>(arg);
   grpc_slice_unref_internal(a->slice);
-  gpr_free(a);
+  delete 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)));
+  shutdown_cleanup_args* sc = new shutdown_cleanup_args;
   GRPC_CLOSURE_INIT(&sc->closure, shutdown_cleanup, sc,
                     grpc_schedule_on_exec_ctx);
   grpc_transport_op* op = grpc_make_transport_op(&sc->closure);
@@ -419,18 +508,34 @@ void send_shutdown(grpc_channel* channel, bool send_goaway,
   elem->filter->start_transport_op(elem, op);
 }
 
-void channel_broadcaster_shutdown(channel_broadcaster* cb, bool send_goaway,
-                                  grpc_error* force_disconnect) {
-  size_t i;
+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
+
+  // This function copies over the channels from the locked server
+  void FillChannelsLocked(const grpc_server* s) {
+    GPR_DEBUG_ASSERT(channels_.empty());
+    channels_.reserve(s->channels.size());
+    for (const channel_data* chand : s->channels) {
+      channels_.push_back(chand->channel);
+      GRPC_CHANNEL_INTERNAL_REF(chand->channel, "broadcast");
+    }
+  }
 
-  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");
+  // Broadcast a shutdown on each channel
+  void BroadcastShutdown(bool send_goaway, grpc_error* force_disconnect) {
+    for (grpc_channel* channel : channels_) {
+      send_shutdown(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);
   }
-  gpr_free(cb->channels);
-  GRPC_ERROR_UNREF(force_disconnect);
-}
+
+ private:
+  std::vector<grpc_channel*> channels_;
+};
 
 /*
  * request_matcher
@@ -444,7 +549,7 @@ void channel_broadcaster_shutdown(channel_broadcaster* cb, bool send_goaway,
 class RealRequestMatcher : public RequestMatcherInterface {
  public:
   explicit RealRequestMatcher(grpc_server* server)
-      : server_(server), requests_per_cq_(server->cq_count) {}
+      : server_(server), requests_per_cq_(server->cqs.size()) {}
 
   ~RealRequestMatcher() override {
     for (LockedMultiProducerSingleConsumerQueue& queue : requests_per_cq_) {
@@ -453,17 +558,16 @@ 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);
+    for (call_data* calld : pending_) {
+      calld->state.Store(CallState::ZOMBIED, grpc_core::MemoryOrder::RELAXED);
       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);
+      ExecCtx::Run(DEBUG_LOCATION, &calld->kill_zombie_closure,
+                   GRPC_ERROR_NONE);
     }
+    pending_.clear();
   }
 
   void KillRequests(grpc_error* error) override {
@@ -486,28 +590,46 @@ class RealRequestMatcher : public RequestMatcherInterface {
     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 {
+        requested_call* rc = nullptr;
+        call_data* calld;
+      };
+      auto pop_next_pending = [this, request_queue_index] {
+        PendingCall pending;
+        {
+          MutexLock lock(&server_->mu_call);
+          if (!pending_.empty()) {
+            pending.rc = reinterpret_cast<requested_call*>(
+                requests_per_cq_[request_queue_index].Pop());
+            if (pending.rc != nullptr) {
+              pending.calld = pending_.front();
+              pending_.pop_front();
+            }
+          }
+        }
+        return pending;
+      };
+      while (true) {
+        PendingCall next_pending = pop_next_pending();
+        if (next_pending.rc == nullptr) break;
+        CallState expect_pending = CallState::PENDING;
+        if (!next_pending.calld->state.CompareExchangeStrong(
+                &expect_pending, CallState::ACTIVATED,
+                grpc_core::MemoryOrder::ACQ_REL,
+                grpc_core::MemoryOrder::RELAXED)) {
           // Zombied Call
           GRPC_CLOSURE_INIT(
-              &calld->kill_zombie_closure, kill_zombie,
-              grpc_call_stack_element(grpc_call_get_call_stack(calld->call), 0),
+              &next_pending.calld->kill_zombie_closure, kill_zombie,
+              grpc_call_stack_element(
+                  grpc_call_get_call_stack(next_pending.calld->call), 0),
               grpc_schedule_on_exec_ctx);
-          grpc_core::ExecCtx::Run(DEBUG_LOCATION, &calld->kill_zombie_closure,
-                                  GRPC_ERROR_NONE);
+          ExecCtx::Run(DEBUG_LOCATION, &next_pending.calld->kill_zombie_closure,
+                       GRPC_ERROR_NONE);
         } else {
-          publish_call(server_, calld, request_queue_index, rc);
+          publish_call(server_, next_pending.calld, request_queue_index,
+                       next_pending.rc);
         }
-        gpr_mu_lock(&server_->mu_call);
       }
-      gpr_mu_unlock(&server_->mu_call);
     }
   }
 
@@ -521,7 +643,8 @@ class RealRequestMatcher : public RequestMatcherInterface {
         continue;
       } else {
         GRPC_STATS_INC_SERVER_CQS_CHECKED(i);
-        gpr_atm_no_barrier_store(&calld->state, ACTIVATED);
+        calld->state.Store(CallState::ACTIVATED,
+                           grpc_core::MemoryOrder::RELAXED);
         publish_call(server_, calld, cq_idx, rc);
         return; /* early out */
       }
@@ -529,43 +652,40 @@ class RealRequestMatcher : public RequestMatcherInterface {
 
     /* 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
     // 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());
+    requested_call* 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<requested_call*>(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->state.Store(CallState::PENDING, grpc_core::MemoryOrder::RELAXED);
+        pending_.push_back(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->state.Store(CallState::ACTIVATED, grpc_core::MemoryOrder::RELAXED);
+    publish_call(server_, calld, cq_idx, rc);
   }
 
   grpc_server* server() const override { return server_; }
 
  private:
   grpc_server* const server_;
-  call_data* pending_head_ = nullptr;
-  call_data* pending_tail_ = nullptr;
+  std::list<call_data*> pending_;
   std::vector<LockedMultiProducerSingleConsumerQueue> requests_per_cq_;
 };
 
@@ -579,12 +699,12 @@ class AllocatingRequestMatcherBase : public RequestMatcherInterface {
   AllocatingRequestMatcherBase(grpc_server* server, grpc_completion_queue* cq)
       : server_(server), cq_(cq) {
     size_t idx;
-    for (idx = 0; idx < server->cq_count; idx++) {
+    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;
   }
 
@@ -619,23 +739,23 @@ class AllocatingRequestMatcherBatch : public AllocatingRequestMatcherBase {
  public:
   AllocatingRequestMatcherBatch(
       grpc_server* server, grpc_completion_queue* cq,
-      std::function<grpc_core::ServerBatchCallAllocation()> allocator)
+      std::function<ServerBatchCallAllocation()> 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_();
+    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);
+    calld->state.Store(CallState::ACTIVATED, grpc_core::MemoryOrder::RELAXED);
     publish_call(server(), calld, cq_idx(), rc);
   }
 
  private:
-  std::function<grpc_core::ServerBatchCallAllocation()> allocator_;
+  std::function<ServerBatchCallAllocation()> allocator_;
 };
 
 // An allocating request matcher for registered methods.
@@ -643,13 +763,13 @@ class AllocatingRequestMatcherRegistered : public AllocatingRequestMatcherBase {
  public:
   AllocatingRequestMatcherRegistered(
       grpc_server* server, grpc_completion_queue* cq, registered_method* rm,
-      std::function<grpc_core::ServerRegisteredCallAllocation()> allocator)
+      std::function<ServerRegisteredCallAllocation()> 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_();
+    ServerRegisteredCallAllocation call_info = allocator_();
     GPR_ASSERT(ValidateServerRequest(cq(), static_cast<void*>(call_info.tag),
                                      call_info.optional_payload,
                                      registered_method_) == GRPC_CALL_OK);
@@ -657,13 +777,13 @@ class AllocatingRequestMatcherRegistered : public AllocatingRequestMatcherBase {
         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);
+    calld->state.Store(CallState::ACTIVATED, grpc_core::MemoryOrder::RELAXED);
     publish_call(server(), calld, cq_idx(), rc);
   }
 
  private:
   registered_method* const registered_method_;
-  std::function<grpc_core::ServerRegisteredCallAllocation()> allocator_;
+  std::function<ServerRegisteredCallAllocation()> allocator_;
 };
 
 /*
@@ -672,42 +792,12 @@ class AllocatingRequestMatcherRegistered : public AllocatingRequestMatcherBase {
 
 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);
+    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;
-}
-
 void finish_destroy_channel(void* cd, grpc_error* /*error*/) {
   channel_data* chand = static_cast<channel_data*>(cd);
   grpc_server* server = chand->server;
@@ -716,9 +806,10 @@ void finish_destroy_channel(void* cd, grpc_error* /*error*/) {
 }
 
 void destroy_channel(channel_data* chand) {
-  if (is_channel_orphaned(chand)) return;
+  if (!chand->list_position.has_value()) return;
   GPR_ASSERT(chand->server != nullptr);
-  orphan_channel(chand);
+  chand->server->channels.erase(*chand->list_position);
+  chand->list_position.reset();
   server_ref(chand->server);
   maybe_finish_shutdown(chand->server);
   GRPC_CLOSURE_INIT(&chand->finish_destroy_channel_closure,
@@ -748,7 +839,7 @@ void publish_call(grpc_server* server, call_data* calld, size_t cq_idx,
   calld->cq_new = server->cqs[cq_idx];
   GPR_SWAP(grpc_metadata_array, *rc->initial_metadata, calld->initial_metadata);
   switch (rc->type) {
-    case BATCH_CALL:
+    case RequestedCallType::BATCH_CALL:
       GPR_ASSERT(calld->host_set);
       GPR_ASSERT(calld->path_set);
       rc->data.batch.details->host = grpc_slice_ref_internal(calld->host);
@@ -757,7 +848,7 @@ void publish_call(grpc_server* server, call_data* calld, size_t cq_idx,
           grpc_millis_to_timespec(calld->deadline, GPR_CLOCK_MONOTONIC);
       rc->data.batch.details->flags = calld->recv_initial_metadata_flags;
       break;
-    case REGISTERED_CALL:
+    case RequestedCallType::REGISTERED_CALL:
       *rc->data.registered.deadline =
           grpc_millis_to_timespec(calld->deadline, GPR_CLOCK_MONOTONIC);
       if (rc->data.registered.optional_payload) {
@@ -780,14 +871,15 @@ void publish_new_rpc(void* arg, grpc_error* error) {
   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);
+  if (error != GRPC_ERROR_NONE ||
+      server->shutdown_flag.load(std::memory_order_acquire)) {
+    calld->state.Store(CallState::ZOMBIED, grpc_core::MemoryOrder::RELAXED);
     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));
+    ExecCtx::Run(DEBUG_LOCATION, &calld->kill_zombie_closure,
+                 GRPC_ERROR_REF(error));
     return;
   }
 
@@ -799,12 +891,11 @@ void finish_start_new_rpc(
     grpc_server_register_method_payload_handling payload_handling) {
   call_data* calld = static_cast<call_data*>(elem->call_data);
 
-  if (gpr_atm_acq_load(&server->shutdown_flag)) {
-    gpr_atm_no_barrier_store(&calld->state, ZOMBIED);
+  if (server->shutdown_flag.load(std::memory_order_acquire)) {
+    calld->state.Store(CallState::ZOMBIED, grpc_core::MemoryOrder::RELAXED);
     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);
+    ExecCtx::Run(DEBUG_LOCATION, &calld->kill_zombie_closure, GRPC_ERROR_NONE);
     return;
   }
 
@@ -842,8 +933,8 @@ void start_new_rpc(grpc_call_element* elem) {
     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];
+      rm = &(*chand->registered_methods)[(hash + i) %
+                                         chand->registered_methods->size()];
       if (rm->server_registered_method == nullptr) break;
       if (!rm->has_host) continue;
       if (rm->host != calld->host) continue;
@@ -861,8 +952,8 @@ void start_new_rpc(grpc_call_element* elem) {
     /* 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];
+      rm = &(*chand->registered_methods)[(hash + i) %
+                                         chand->registered_methods->size()];
       if (rm->server_registered_method == nullptr) break;
       if (rm->has_host) continue;
       if (rm->method != calld->path) continue;
@@ -877,39 +968,21 @@ void start_new_rpc(grpc_call_element* elem) {
       return;
     }
   }
-  finish_start_new_rpc(server, elem, server->unregistered_request_matcher,
+  finish_start_new_rpc(server, elem, server->unregistered_request_matcher.get(),
                        GRPC_SRM_PAYLOAD_NONE);
 }
 
-int num_listeners(grpc_server* server) {
-  listener* l;
-  int n = 0;
-  for (l = server->listeners; l; l = l->next) {
-    n++;
-  }
-  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++;
-  }
-  return n;
-}
+int num_channels(grpc_server* server) { return server->channels.size(); }
 
 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) {
+    for (std::unique_ptr<registered_method>& rm : server->registered_methods) {
       rm->matcher->KillRequests(GRPC_ERROR_REF(error));
       rm->matcher->ZombifyPending();
     }
@@ -919,32 +992,34 @@ void kill_pending_work_locked(grpc_server* server, grpc_error* error) {
 
 void maybe_finish_shutdown(grpc_server* server) {
   size_t i;
-  if (!gpr_atm_acq_load(&server->shutdown_flag) || server->shutdown_published) {
+  if (!server->shutdown_flag.load(std::memory_order_acquire) ||
+      server->shutdown_published) {
     return;
   }
 
-  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);
+  {
+    MutexLock lock(&server->mu_call);
+    kill_pending_work_locked(
+        server, GRPC_ERROR_CREATE_FROM_STATIC_STRING("Server Shutdown"));
+  }
 
-  if (server->root_channel_data.next != &server->root_channel_data ||
-      server->listeners_destroyed < num_listeners(server)) {
+  if (!server->channels.empty() ||
+      server->listeners_destroyed < server->listeners.size()) {
     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",
+              "Waiting for %d channels and %" PRIuPTR "/%" PRIuPTR
+              " listeners to be destroyed before shutting down server",
               num_channels(server),
-              num_listeners(server) - server->listeners_destroyed,
-              num_listeners(server));
+              server->listeners.size() - server->listeners_destroyed,
+              server->listeners.size());
     }
     return;
   }
   server->shutdown_published = 1;
-  for (i = 0; i < server->num_shutdown_tags; i++) {
+  for (i = 0; i < server->shutdown_tags.size(); 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,
@@ -995,7 +1070,7 @@ void server_on_recv_initial_metadata(void* ptr, grpc_error* error) {
                              calld->recv_trailing_metadata_error,
                              "continue server_recv_trailing_metadata_ready");
   }
-  grpc_core::Closure::Run(DEBUG_LOCATION, closure, error);
+  Closure::Run(DEBUG_LOCATION, closure, error);
 }
 
 void server_recv_trailing_metadata_ready(void* user_data, grpc_error* error) {
@@ -1015,8 +1090,8 @@ void server_recv_trailing_metadata_ready(void* user_data, grpc_error* error) {
   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);
+  Closure::Run(DEBUG_LOCATION, calld->original_recv_trailing_metadata_ready,
+               error);
 }
 
 void server_mutate_op(grpc_call_element* elem,
@@ -1030,7 +1105,7 @@ void server_mutate_op(grpc_call_element* elem,
     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;
+        &calld->on_recv_initial_metadata;
     op->payload->recv_initial_metadata.recv_flags =
         &calld->recv_initial_metadata_flags;
   }
@@ -1054,12 +1129,19 @@ void got_initial_metadata(void* ptr, grpc_error* error) {
   if (error == GRPC_ERROR_NONE) {
     start_new_rpc(elem);
   } else {
-    if (gpr_atm_full_cas(&calld->state, NOT_STARTED, ZOMBIED)) {
+    CallState expect_not_started = CallState::NOT_STARTED;
+    CallState expect_pending = CallState::PENDING;
+    if (calld->state.CompareExchangeStrong(
+            &expect_not_started, CallState::ZOMBIED,
+            grpc_core::MemoryOrder::ACQ_REL, grpc_core::MemoryOrder::RELAXED)) {
       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)) {
+      ExecCtx::Run(DEBUG_LOCATION, &calld->kill_zombie_closure,
+                   GRPC_ERROR_NONE);
+    } else if (calld->state.CompareExchangeStrong(
+                   &expect_pending, CallState::ZOMBIED,
+                   grpc_core::MemoryOrder::ACQ_REL,
+                   grpc_core::MemoryOrder::RELAXED)) {
       /* zombied call will be destroyed when it's removed from the pending
          queue... later */
     }
@@ -1121,63 +1203,56 @@ void server_destroy_call_elem(grpc_call_element* elem,
 
 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;
+
+  new (static_cast<channel_data*>(elem->channel_data)) channel_data;
   return GRPC_ERROR_NONE;
 }
 
-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);
+channel_data::~channel_data() {
+  if (registered_methods) {
+    for (const channel_registered_method& crm : *registered_methods) {
+      grpc_slice_unref_internal(crm.method);
+      GPR_DEBUG_ASSERT(crm.method.refcount == &kNoopRefcount ||
+                       crm.method.refcount == nullptr);
+      if (crm.has_host) {
+        grpc_slice_unref_internal(crm.host);
+        GPR_DEBUG_ASSERT(crm.host.refcount == &kNoopRefcount ||
+                         crm.host.refcount == nullptr);
       }
     }
-    gpr_free(chand->registered_methods);
   }
-  if (chand->server) {
-    if (chand->server->channelz_server != nullptr &&
-        chand->channelz_socket_uuid != 0) {
-      chand->server->channelz_server->RemoveChildSocket(
-          chand->channelz_socket_uuid);
+  if (server) {
+    if (server->channelz_server != nullptr && channelz_socket_uuid != 0) {
+      server->channelz_server->RemoveChildSocket(channelz_socket_uuid);
+    }
+    {
+      MutexLock lock(&server->mu_global);
+      if (list_position.has_value()) {
+        server->channels.erase(*list_position);
+      }
+      maybe_finish_shutdown(server);
     }
-    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);
+    server_unref(server);
   }
 }
 
+void server_destroy_channel_elem(grpc_channel_element* elem) {
+  channel_data* chand = static_cast<channel_data*>(elem->channel_data);
+  chand->~channel_data();
+}
+
 void register_completion_queue(grpc_server* server, grpc_completion_queue* cq,
                                void* reserved) {
-  size_t i, n;
+  size_t i;
   GPR_ASSERT(!reserved);
-  for (i = 0; i < server->cq_count; i++) {
+  for (i = 0; i < server->cqs.size(); i++) {
     if (server->cqs[i] == cq) return;
   }
 
   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;
+  server->cqs.push_back(cq);
 }
 
 bool streq(const std::string& a, const char* b) {
@@ -1185,8 +1260,7 @@ bool streq(const std::string& a, const char* b) {
          ((b != nullptr) && !strcmp(a.c_str(), b));
 }
 
-class ConnectivityWatcher
-    : public grpc_core::AsyncConnectivityStateWatcherInterface {
+class ConnectivityWatcher : public AsyncConnectivityStateWatcherInterface {
  public:
   explicit ConnectivityWatcher(channel_data* chand) : chand_(chand) {
     GRPC_CHANNEL_INTERNAL_REF(chand_->channel, "connectivity");
@@ -1202,40 +1276,37 @@ class ConnectivityWatcher
     if (new_state != GRPC_CHANNEL_SHUTDOWN) return;
     // Shut down channel.
     grpc_server* server = chand_->server;
-    gpr_mu_lock(&server->mu_global);
+    MutexLock lock(&server->mu_global);
     destroy_channel(chand_);
-    gpr_mu_unlock(&server->mu_global);
   }
 
   channel_data* chand_;
 };
 
-void done_published_shutdown(void* done_arg, grpc_cq_completion* storage) {
-  (void)done_arg;
-  gpr_free(storage);
+void done_published_shutdown(void* /*done_arg*/, grpc_cq_completion* storage) {
+  delete storage;
 }
 
 void listener_destroy_done(void* s, grpc_error* /*error*/) {
   grpc_server* server = static_cast<grpc_server*>(s);
-  gpr_mu_lock(&server->mu_global);
+  MutexLock lock(&server->mu_global);
   server->listeners_destroyed++;
   maybe_finish_shutdown(server);
-  gpr_mu_unlock(&server->mu_global);
 }
 
 grpc_call_error queue_call_request(grpc_server* server, size_t cq_idx,
                                    requested_call* rc) {
-  if (gpr_atm_acq_load(&server->shutdown_flag)) {
+  if (server->shutdown_flag.load(std::memory_order_acquire)) {
     fail_call(server, 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 RequestedCallType::BATCH_CALL:
+      rm = server->unregistered_request_matcher.get();
       break;
-    case REGISTERED_CALL:
+    case RequestedCallType::REGISTERED_CALL:
       rm = rc->data.registered.method->matcher.get();
       break;
   }
@@ -1252,16 +1323,15 @@ void fail_call(grpc_server* server, size_t cq_idx, requested_call* rc,
   grpc_cq_end_op(server->cqs[cq_idx], rc->tag, error, done_request_event, rc,
                  &rc->completion);
 }
-}  // namespace
 
-namespace grpc_core {
+}  // namespace
 
 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)));
+  rm->matcher = absl::make_unique<AllocatingRequestMatcherRegistered>(
+      server, cq, rm, std::move(allocator));
 }
 
 void SetServerBatchMethodAllocator(
@@ -1269,25 +1339,28 @@ void SetServerBatchMethodAllocator(
     std::function<ServerBatchCallAllocation()> allocator) {
   GPR_DEBUG_ASSERT(server->unregistered_request_matcher == nullptr);
   server->unregistered_request_matcher =
-      new AllocatingRequestMatcherBatch(server, cq, std::move(allocator));
+      absl::make_unique<AllocatingRequestMatcherBatch>(server, cq,
+                                                       std::move(allocator));
 }
 
-};  // namespace grpc_core
+}  // namespace grpc_core
 
 const grpc_channel_filter grpc_server_top_filter = {
-    server_start_transport_stream_op_batch,
+    grpc_core::server_start_transport_stream_op_batch,
     grpc_channel_next_op,
-    sizeof(call_data),
-    server_init_call_elem,
+    sizeof(grpc_core::call_data),
+    grpc_core::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_core::server_destroy_call_elem,
+    sizeof(grpc_core::channel_data),
+    grpc_core::server_init_channel_elem,
+    grpc_core::server_destroy_channel_elem,
     grpc_channel_next_get_info,
     "server",
 };
 
+// The following are core surface API functions.
+
 void grpc_server_register_completion_queue(grpc_server* server,
                                            grpc_completion_queue* cq,
                                            void* reserved) {
@@ -1305,59 +1378,20 @@ void grpc_server_register_completion_queue(grpc_server* server,
        calls grpc_completion_queue_pluck() on server completion queues */
   }
 
-  register_completion_queue(server, cq, reserved);
+  grpc_core::register_completion_queue(server, cq, reserved);
 }
 
 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);
-
-  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"));
-  }
-
-  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");
-    }
-  }
-
-  return server;
+  return new grpc_server(args);
 }
 
 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)",
@@ -1367,8 +1401,10 @@ void* grpc_server_register_method(
             "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)) {
+  for (std::unique_ptr<grpc_core::registered_method>& m :
+       server->registered_methods) {
+    if (grpc_core::streq(m->method, method) &&
+        grpc_core::streq(m->host, host)) {
       gpr_log(GPR_ERROR, "duplicate registration for %s@%s", method,
               host ? host : "*");
       return nullptr;
@@ -1379,10 +1415,9 @@ void* grpc_server_register_method(
             flags);
     return nullptr;
   }
-  m = new registered_method(method, host, payload_handling, flags);
-  m->next = server->registered_methods;
-  server->registered_methods = m;
-  return m;
+  server->registered_methods.emplace_back(
+      new grpc_core::registered_method(method, host, payload_handling, flags));
+  return static_cast<void*>(server->registered_methods.back().get());
 }
 
 void grpc_server_start(grpc_server* server) {
@@ -1392,42 +1427,156 @@ void grpc_server_start(grpc_server* server) {
   GRPC_API_TRACE("grpc_server_start(server=%p)", 1, (server));
 
   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++) {
+  for (i = 0; i < server->cqs.size(); i++) {
     if (grpc_cq_can_listen(server->cqs[i])) {
-      server->pollsets[server->pollset_count++] =
-          grpc_cq_pollset(server->cqs[i]);
+      server->pollsets.push_back(grpc_cq_pollset(server->cqs[i]));
     }
   }
   if (server->unregistered_request_matcher == nullptr) {
-    server->unregistered_request_matcher = new RealRequestMatcher(server);
+    server->unregistered_request_matcher =
+        absl::make_unique<grpc_core::RealRequestMatcher>(server);
   }
-  for (registered_method* rm = server->registered_methods; rm; rm = rm->next) {
+  for (std::unique_ptr<grpc_core::registered_method>& rm :
+       server->registered_methods) {
     if (rm->matcher == nullptr) {
-      rm->matcher.reset(new RealRequestMatcher(server));
+      rm->matcher = absl::make_unique<grpc_core::RealRequestMatcher>(server);
     }
   }
 
-  gpr_mu_lock(&server->mu_global);
-  server->starting = true;
-  gpr_mu_unlock(&server->mu_global);
+  {
+    grpc_core::MutexLock lock(&server->mu_global);
+    server->starting = true;
+  }
 
-  for (listener* l = server->listeners; l; l = l->next) {
-    l->start(server, l->arg, server->pollsets, server->pollset_count);
+  for (auto& listener : server->listeners) {
+    listener.listener->Start(server, &server->pollsets);
   }
 
-  gpr_mu_lock(&server->mu_global);
+  grpc_core::MutexLock lock(&server->mu_global);
   server->starting = false;
-  gpr_cv_signal(&server->starting_cv);
-  gpr_mu_unlock(&server->mu_global);
+  server->starting_cv.Signal();
+}
+
+/*
+  - 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
+    'ChannelBroadcaster::BroadcastShutdown' 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) {
+  grpc_core::ChannelBroadcaster broadcaster;
+  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));
+
+  {
+    /* wait for startup to be finished: locks mu_global */
+    grpc_core::MutexLock lock(&server->mu_global);
+    server->starting_cv.WaitUntil(&server->mu_global,
+                                  [server] { return !server->starting; });
+
+    /* 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,
+                     grpc_core::done_published_shutdown, nullptr,
+                     new grpc_cq_completion);
+      return;
+    }
+    server->shutdown_tags.emplace_back(tag, cq);
+    if (server->shutdown_flag.load(std::memory_order_acquire)) {
+      return;
+    }
+
+    server->last_shutdown_message_time = gpr_now(GPR_CLOCK_REALTIME);
+
+    broadcaster.FillChannelsLocked(server);
+
+    server->shutdown_flag.store(true, std::memory_order_release);
+
+    /* collect all unregistered then registered calls */
+    {
+      grpc_core::MutexLock lock(&server->mu_call);
+      grpc_core::kill_pending_work_locked(
+          server, GRPC_ERROR_CREATE_FROM_STATIC_STRING("Server Shutdown"));
+    }
+
+    grpc_core::maybe_finish_shutdown(server);
+  }
+
+  /* Shutdown listeners */
+  for (auto& listener : server->listeners) {
+    grpc_core::channelz::ListenSocketNode* channelz_listen_socket_node =
+        listener.listener->channelz_listen_socket_node();
+    if (server->channelz_server != nullptr &&
+        channelz_listen_socket_node != nullptr) {
+      server->channelz_server->RemoveChildListenSocket(
+          channelz_listen_socket_node->uuid());
+    }
+    GRPC_CLOSURE_INIT(&listener.destroy_done, grpc_core::listener_destroy_done,
+                      server, grpc_schedule_on_exec_ctx);
+    listener.listener->SetOnDestroyDone(&listener.destroy_done);
+    listener.listener.reset();
+  }
+
+  broadcaster.BroadcastShutdown(/*send_goaway=*/true, GRPC_ERROR_NONE);
 }
 
-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_cancel_all_calls(grpc_server* server) {
+  grpc_core::ChannelBroadcaster broadcaster;
+  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::MutexLock lock(&server->mu_global);
+    broadcaster.FillChannelsLocked(server);
+  }
+
+  broadcaster.BroadcastShutdown(
+      /*send_goaway=*/false,
+      GRPC_ERROR_CREATE_FROM_STATIC_STRING("Cancelling all calls"));
+}
+
+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::MutexLock lock(&server->mu_global);
+    GPR_ASSERT(server->shutdown_flag.load(std::memory_order_acquire) ||
+               server->listeners.empty());
+    GPR_ASSERT(server->listeners_destroyed == server->listeners.size());
+  }
+
+  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);
+  }
+  grpc_core::server_unref(server);
+}
+
+const std::vector<grpc_pollset*>& grpc_server_get_pollsets(
+    grpc_server* server) {
+  return server->pollsets;
 }
 
 void grpc_server_setup_transport(
@@ -1437,11 +1586,9 @@ void grpc_server_setup_transport(
         socket_node,
     grpc_resource_user* resource_user) {
   size_t num_registered_methods;
-  size_t alloc;
-  registered_method* rm;
-  channel_registered_method* crm;
+  grpc_core::channel_registered_method* crm;
   grpc_channel* channel;
-  channel_data* chand;
+  grpc_core::channel_data* chand;
   uint32_t hash;
   size_t slots;
   uint32_t probes;
@@ -1450,11 +1597,11 @@ void grpc_server_setup_transport(
 
   channel = grpc_channel_create(nullptr, args, GRPC_SERVER_CHANNEL, transport,
                                 resource_user);
-  chand = static_cast<channel_data*>(
+  chand = static_cast<grpc_core::channel_data*>(
       grpc_channel_stack_element(grpc_channel_get_channel_stack(channel), 0)
           ->channel_data);
   chand->server = s;
-  server_ref(s);
+  grpc_core::server_ref(s);
   chand->channel = channel;
   if (socket_node != nullptr) {
     chand->channelz_socket_uuid = socket_node->uuid();
@@ -1464,27 +1611,24 @@ void grpc_server_setup_transport(
   }
 
   size_t cq_idx;
-  for (cq_idx = 0; cq_idx < s->cq_count; cq_idx++) {
+  for (cq_idx = 0; cq_idx < s->cqs.size(); cq_idx++) {
     if (grpc_cq_pollset(s->cqs[cq_idx]) == accepting_pollset) break;
   }
-  if (cq_idx == s->cq_count) {
+  if (cq_idx == s->cqs.size()) {
     /* completion queue not found: pick a random one to publish new calls to */
-    cq_idx = static_cast<size_t>(rand()) % s->cq_count;
+    cq_idx = static_cast<size_t>(rand()) % s->cqs.size();
   }
   chand->cq_idx = cq_idx;
 
-  num_registered_methods = 0;
-  for (rm = s->registered_methods; rm; rm = rm->next) {
-    num_registered_methods++;
-  }
+  num_registered_methods = s->registered_methods.size();
   /* build a lookup table phrased in terms of mdstr's in this channels context
      to quickly find registered methods */
   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) {
+    chand->registered_methods.reset(
+        new std::vector<grpc_core::channel_registered_method>(slots));
+    for (std::unique_ptr<grpc_core::registered_method>& rm :
+         s->registered_methods) {
       grpc_core::ExternallyManagedSlice host;
       grpc_core::ExternallyManagedSlice method(rm->method.c_str());
       const bool has_host = !rm->host.empty();
@@ -1492,13 +1636,13 @@ void grpc_server_setup_transport(
         host = grpc_core::ExternallyManagedSlice(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]
+      for (probes = 0; (*chand->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;
+      crm = &(*chand->registered_methods)[(hash + probes) % slots];
+      crm->server_registered_method = rm.get();
       crm->flags = rm->flags;
       crm->has_host = has_host;
       if (has_host) {
@@ -1507,215 +1651,27 @@ void grpc_server_setup_transport(
       crm->method = method;
     }
     GPR_ASSERT(slots <= UINT32_MAX);
-    chand->registered_method_slots = static_cast<uint32_t>(slots);
     chand->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);
+  {
+    grpc_core::MutexLock lock(&s->mu_global);
+    s->channels.push_front(chand);
+    chand->list_position = s->channels.begin();
+  }
 
   op = grpc_make_transport_op(nullptr);
   op->set_accept_stream = true;
-  op->set_accept_stream_fn = accept_stream;
+  op->set_accept_stream_fn = grpc_core::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->start_connectivity_watch.reset(new grpc_core::ConnectivityWatcher(chand));
+  if (s->shutdown_flag.load(std::memory_order_acquire)) {
     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;
-
-  GRPC_API_TRACE("grpc_server_shutdown_and_notify(server=%p, cq=%p, tag=%p)", 3,
-                 (server, cq, tag));
-
-  /* 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));
-  }
-
-  /* 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;
-  }
-  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;
-  }
-
-  server->last_shutdown_message_time = gpr_now(GPR_CLOCK_REALTIME);
-
-  channel_broadcaster_init(server, &broadcaster);
-
-  gpr_atm_rel_store(&server->shutdown_flag, 1);
-
-  /* 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);
-
-  maybe_finish_shutdown(server);
-  gpr_mu_unlock(&server->mu_global);
-
-  /* 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);
-    }
-  }
-
-  channel_broadcaster_shutdown(&broadcaster, true /* send_goaway */,
-                               GRPC_ERROR_NONE);
-
-  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 grpc_server_cancel_all_calls(grpc_server* server) {
-  channel_broadcaster broadcaster;
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
-  grpc_core::ExecCtx exec_ctx;
-
-  GRPC_API_TRACE("grpc_server_cancel_all_calls(server=%p)", 1, (server));
-
-  gpr_mu_lock(&server->mu_global);
-  channel_broadcaster_init(server, &broadcaster);
-  gpr_mu_unlock(&server->mu_global);
-
-  channel_broadcaster_shutdown(
-      &broadcaster, false /* send_goaway */,
-      GRPC_ERROR_CREATE_FROM_STATIC_STRING("Cancelling all calls"));
-}
-
-void grpc_server_destroy(grpc_server* server) {
-  listener* l;
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
-  grpc_core::ExecCtx exec_ctx;
-
-  GRPC_API_TRACE("grpc_server_destroy(server=%p)", 1, (server));
-
-  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));
-
-  while (server->listeners) {
-    l = server->listeners;
-    server->listeners = l->next;
-    gpr_free(l);
-  }
-
-  gpr_mu_unlock(&server->mu_global);
-
-  server_unref(server);
-}
-
-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;
-}
-
-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;
-}
-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;
-}
-}  // namespace
-
 grpc_call_error grpc_server_request_call(
     grpc_server* server, grpc_call** call, grpc_call_details* details,
     grpc_metadata_array* initial_metadata,
@@ -1733,14 +1689,14 @@ grpc_call_error grpc_server_request_call(
        cq_for_notification, tag));
 
   size_t cq_idx;
-  grpc_call_error error = ValidateServerRequestAndCq(
+  grpc_call_error error = grpc_core::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);
+  grpc_core::requested_call* rc = new grpc_core::requested_call(
+      tag, cq_bound_to_call, call, initial_metadata, details);
   return queue_call_request(server, cq_idx, rc);
 }
 
@@ -1748,11 +1704,12 @@ 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_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);
+  grpc_core::registered_method* rm =
+      static_cast<grpc_core::registered_method*>(rmp);
   GRPC_API_TRACE(
       "grpc_server_request_registered_call("
       "server=%p, rmp=%p, call=%p, deadline=%p, initial_metadata=%p, "
@@ -1760,41 +1717,17 @@ grpc_call_error grpc_server_request_registered_call(
       "tag=%p)",
       9,
       (server, rmp, call, deadline, initial_metadata, optional_payload,
-       cq_bound_to_call, cq_for_notification, tag));
+       cq_bound_to_call, cq_for_notification, tag_new));
 
   size_t cq_idx;
   grpc_call_error error = ValidateServerRequestAndCq(
-      &cq_idx, server, cq_for_notification, tag, optional_payload, rm);
+      &cq_idx, server, cq_for_notification, tag_new, 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);
+  grpc_core::requested_call* rc = new grpc_core::requested_call(
+      tag_new, 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;
-}
-
-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;
-}
-
-grpc_core::channelz::ServerNode* grpc_server_get_channelz_node(
-    grpc_server* server) {
-  if (server == nullptr) {
-    return nullptr;
-  }
-  return server->channelz_server.get();
-}