grpc 1.42.0 → 1.43.1

data/src/core/ext/filters/server_config_selector/server_config_selector_filter.h

@@ -0,0 +1,32 @@
+//
+//
+// Copyright 2021 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+#ifndef GRPC_CORE_EXT_FILTERS_SERVER_CONFIG_SELECTOR_SERVER_CONFIG_SELECTOR_FILTER_H
+#define GRPC_CORE_EXT_FILTERS_SERVER_CONFIG_SELECTOR_SERVER_CONFIG_SELECTOR_FILTER_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/channel/channel_stack.h"
+
+namespace grpc_core {
+
+extern const grpc_channel_filter kServerConfigSelectorFilter;
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_EXT_FILTERS_SERVER_CONFIG_SELECTOR_SERVER_CONFIG_SELECTOR_FILTER_H

data/src/core/ext/transport/chttp2/client/chttp2_connector.cc

@@ -43,9 +43,6 @@ Chttp2Connector::Chttp2Connector() {
 }
 
 Chttp2Connector::~Chttp2Connector() {
-  if (resource_quota_ != nullptr) {
-    grpc_resource_quota_unref_internal(resource_quota_);
-  }
   if (endpoint_ != nullptr) {
     grpc_endpoint_destroy(endpoint_);
   }
@@ -64,11 +61,6 @@ void Chttp2Connector::Connect(const Args& args, Result* result,
     connecting_ = true;
     GPR_ASSERT(endpoint_ == nullptr);
     ep = &endpoint_;
-    if (resource_quota_ != nullptr) {
-      grpc_resource_quota_unref_internal(resource_quota_);
-    }
-    resource_quota_ =
-        grpc_resource_quota_from_channel_args(args.channel_args, true);
   }
   // In some implementations, the closure can be flushed before
   // grpc_tcp_client_connect() returns, and since the closure requires access
@@ -77,12 +69,8 @@ void Chttp2Connector::Connect(const Args& args, Result* result,
   // grpc_tcp_client_connect() will fill endpoint_ with proper contents, and we
   // make sure that we still exist at that point by taking a ref.
   Ref().release();  // Ref held by callback.
-  grpc_tcp_client_connect(
-      &connected_, ep,
-      grpc_slice_allocator_create(resource_quota_,
-                                  grpc_sockaddr_to_string(args.address, false),
-                                  args.channel_args),
-      args.interested_parties, args.channel_args, args.address, args.deadline);
+  grpc_tcp_client_connect(&connected_, ep, args.interested_parties,
+                          args.channel_args, args.address, args.deadline);
 }
 
 void Chttp2Connector::Shutdown(grpc_error_handle error) {
@@ -175,12 +163,8 @@ void Chttp2Connector::OnHandshakeDone(void* arg, grpc_error_handle error) {
       self->result_->Reset();
       NullThenSchedClosure(DEBUG_LOCATION, &self->notify_, error);
     } else if (args->endpoint != nullptr) {
-      self->result_->transport = grpc_create_chttp2_transport(
-          args->args, args->endpoint, true,
-          grpc_resource_user_create(
-              self->resource_quota_,
-              absl::StrCat(grpc_endpoint_get_peer(args->endpoint),
-                           ":connector_transport")));
+      self->result_->transport =
+          grpc_create_chttp2_transport(args->args, args->endpoint, true);
       self->result_->socket_node =
           grpc_chttp2_transport_get_socket_node(self->result_->transport);
       self->result_->channel_args = args->args;

data/src/core/ext/transport/chttp2/client/chttp2_connector.h

@@ -24,7 +24,6 @@
 #include "src/core/ext/filters/client_channel/connector.h"
 #include "src/core/lib/channel/handshaker.h"
 #include "src/core/lib/channel/handshaker_registry.h"
-#include "src/core/lib/iomgr/resource_quota.h"
 
 namespace grpc_core {
 
@@ -69,7 +68,6 @@ class Chttp2Connector : public SubchannelConnector {
   grpc_closure on_timeout_;
   absl::optional<grpc_error_handle> notify_error_;
   RefCountedPtr<HandshakeManager> handshake_mgr_;
-  grpc_resource_quota* resource_quota_ = nullptr;
 };
 
 }  // namespace grpc_core

data/src/core/ext/transport/chttp2/client/insecure/channel_create.cc

@@ -26,6 +26,7 @@
 #include "src/core/ext/filters/client_channel/resolver_registry.h"
 #include "src/core/ext/transport/chttp2/client/chttp2_connector.h"
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/resource_quota/api.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/channel.h"
 
@@ -52,15 +53,19 @@ grpc_channel* CreateChannel(const char* target, const grpc_channel_args* args,
     return nullptr;
   }
   // Add channel arg containing the server URI.
-  grpc_core::UniquePtr<char> canonical_target =
+  UniquePtr<char> canonical_target =
       ResolverRegistry::AddDefaultPrefixIfNeeded(target);
   grpc_arg arg = grpc_channel_arg_string_create(
       const_cast<char*>(GRPC_ARG_SERVER_URI), canonical_target.get());
   const char* to_remove[] = {GRPC_ARG_SERVER_URI};
-  grpc_channel_args* new_args =
+  grpc_channel_args* new_args0 =
       grpc_channel_args_copy_and_add_and_remove(args, to_remove, 1, &arg, 1);
+  const grpc_channel_args* new_args = CoreConfiguration::Get()
+                                          .channel_args_preconditioning()
+                                          .PreconditionChannelArgs(new_args0);
+  grpc_channel_args_destroy(new_args0);
   grpc_channel* channel = grpc_channel_create(
-      target, new_args, GRPC_CLIENT_CHANNEL, nullptr, nullptr, 0, error);
+      target, new_args, GRPC_CLIENT_CHANNEL, nullptr, error);
   grpc_channel_args_destroy(new_args);
   return channel;
 }
@@ -88,7 +93,6 @@ grpc_channel* grpc_insecure_channel_create(const char* target,
                                            const grpc_channel_args* args,
                                            void* reserved) {
   grpc_core::ExecCtx exec_ctx;
-  args = grpc_channel_args_remove_grpc_internal(args);
   GRPC_API_TRACE(
       "grpc_insecure_channel_create(target=%s, args=%p, reserved=%p)", 3,
       (target, args, reserved));
@@ -104,7 +108,6 @@ grpc_channel* grpc_insecure_channel_create(const char* target,
   grpc_channel* channel = grpc_core::CreateChannel(target, new_args, &error);
   // Clean up.
   grpc_channel_args_destroy(new_args);
-  grpc_channel_args_destroy(args);
   if (channel == nullptr) {
     intptr_t integer;
     grpc_status_code status = GRPC_STATUS_INTERNAL;

data/src/core/ext/transport/chttp2/client/insecure/channel_create_posix.cc

@@ -31,6 +31,7 @@
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/tcp_client_posix.h"
 #include "src/core/lib/iomgr/tcp_posix.h"
+#include "src/core/lib/resource_quota/api.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/transport/transport.h"
@@ -44,26 +45,22 @@ grpc_channel* grpc_insecure_channel_create_from_fd(
   grpc_arg default_authority_arg = grpc_channel_arg_string_create(
       const_cast<char*>(GRPC_ARG_DEFAULT_AUTHORITY),
       const_cast<char*>("test.authority"));
-  grpc_channel_args* final_args =
-      grpc_channel_args_copy_and_add(args, &default_authority_arg, 1);
+  args = grpc_channel_args_copy_and_add(args, &default_authority_arg, 1);
+  const grpc_channel_args* final_args = grpc_core::CoreConfiguration::Get()
+                                            .channel_args_preconditioning()
+                                            .PreconditionChannelArgs(args);
+  grpc_channel_args_destroy(args);
 
   int flags = fcntl(fd, F_GETFL, 0);
   GPR_ASSERT(fcntl(fd, F_SETFL, flags | O_NONBLOCK) == 0);
-  grpc_resource_quota* resource_quota =
-      grpc_resource_quota_from_channel_args(args, true);
-  grpc_slice_allocator* allocator = grpc_slice_allocator_create(
-      resource_quota, "fd-client:endpoint", final_args);
   grpc_endpoint* client = grpc_tcp_client_create_from_fd(
-      grpc_fd_create(fd, "client", true), args, "fd-client", allocator);
-  grpc_transport* transport = grpc_create_chttp2_transport(
-      final_args, client, true,
-      grpc_resource_user_create(resource_quota, "fd-client:transport"));
-  grpc_resource_quota_unref_internal(resource_quota);
+      grpc_fd_create(fd, "client", true), final_args, "fd-client");
+  grpc_transport* transport =
+      grpc_create_chttp2_transport(final_args, client, true);
   GPR_ASSERT(transport);
   grpc_error_handle error = GRPC_ERROR_NONE;
-  grpc_channel* channel =
-      grpc_channel_create(target, final_args, GRPC_CLIENT_DIRECT_CHANNEL,
-                          transport, nullptr, 0, &error);
+  grpc_channel* channel = grpc_channel_create(
+      target, final_args, GRPC_CLIENT_DIRECT_CHANNEL, transport, &error);
   grpc_channel_args_destroy(final_args);
   if (channel != nullptr) {
     grpc_chttp2_transport_start_reading(transport, nullptr, nullptr, nullptr);

data/src/core/ext/transport/chttp2/client/secure/secure_channel_create.cc

@@ -28,6 +28,7 @@
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/resource_quota/api.h"
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/security/security_connector/security_connector.h"
 #include "src/core/lib/slice/slice_internal.h"
@@ -112,7 +113,7 @@ grpc_channel* CreateChannel(const char* target, const grpc_channel_args* args,
     return nullptr;
   }
   // Add channel arg containing the server URI.
-  grpc_core::UniquePtr<char> canonical_target =
+  UniquePtr<char> canonical_target =
       ResolverRegistry::AddDefaultPrefixIfNeeded(target);
   grpc_arg arg = grpc_channel_arg_string_create(
       const_cast<char*>(GRPC_ARG_SERVER_URI), canonical_target.get());
@@ -120,7 +121,7 @@ grpc_channel* CreateChannel(const char* target, const grpc_channel_args* args,
   grpc_channel_args* new_args =
       grpc_channel_args_copy_and_add_and_remove(args, to_remove, 1, &arg, 1);
   grpc_channel* channel = grpc_channel_create(
-      target, new_args, GRPC_CLIENT_CHANNEL, nullptr, nullptr, 0, error);
+      target, new_args, GRPC_CLIENT_CHANNEL, nullptr, error);
   grpc_channel_args_destroy(new_args);
   return channel;
 }
@@ -154,7 +155,9 @@ grpc_channel* grpc_secure_channel_create(grpc_channel_credentials* creds,
       "reserved=%p)",
       4, ((void*)creds, target, (void*)args, (void*)reserved));
   GPR_ASSERT(reserved == nullptr);
-  args = grpc_channel_args_remove_grpc_internal(args);
+  args = grpc_core::CoreConfiguration::Get()
+             .channel_args_preconditioning()
+             .PreconditionChannelArgs(args);
   grpc_channel* channel = nullptr;
   grpc_error_handle error = GRPC_ERROR_NONE;
   if (creds != nullptr) {

data/src/core/ext/transport/chttp2/server/chttp2_server.cc

@@ -29,6 +29,7 @@
 #include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
+#include "absl/strings/strip.h"
 
 #include <grpc/grpc.h>
 #include <grpc/impl/codegen/grpc_types.h>
@@ -47,12 +48,14 @@
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/resolve_address.h"
-#include "src/core/lib/iomgr/resource_quota.h"
 #include "src/core/lib/iomgr/tcp_server.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
+#include "src/core/lib/resource_quota/api.h"
+#include "src/core/lib/resource_quota/memory_quota.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/server.h"
+#include "src/core/lib/uri/uri_parser.h"
 
 namespace grpc_core {
 namespace {
@@ -73,8 +76,7 @@ class Chttp2ServerListener : public Server::ListenerInterface {
 
   // Do not instantiate directly.  Use one of the factory methods above.
   Chttp2ServerListener(Server* server, grpc_channel_args* args,
-                       Chttp2ServerArgsModifier args_modifier,
-                       grpc_resource_quota* resource_quota);
+                       Chttp2ServerArgsModifier args_modifier);
   ~Chttp2ServerListener() override;
 
   void Start(Server* server,
@@ -112,8 +114,7 @@ class Chttp2ServerListener : public Server::ListenerInterface {
       HandshakingState(RefCountedPtr<ActiveConnection> connection_ref,
                        grpc_pollset* accepting_pollset,
                        grpc_tcp_server_acceptor* acceptor,
-                       grpc_channel_args* args,
-                       grpc_resource_user* channel_resource_user);
+                       grpc_channel_args* args);
 
       ~HandshakingState() override;
 
@@ -139,13 +140,11 @@ class Chttp2ServerListener : public Server::ListenerInterface {
       grpc_closure on_timeout_ ABSL_GUARDED_BY(&connection_->mu_);
       grpc_closure on_receive_settings_ ABSL_GUARDED_BY(&connection_->mu_);
       grpc_pollset_set* const interested_parties_;
-      grpc_resource_user* channel_resource_user_;
     };
 
     ActiveConnection(grpc_pollset* accepting_pollset,
                      grpc_tcp_server_acceptor* acceptor,
-                     grpc_channel_args* args,
-                     grpc_resource_user* channel_resource_user);
+                     grpc_channel_args* args, MemoryOwner memory_owner);
     ~ActiveConnection() override;
 
     void Orphan() override;
@@ -239,7 +238,7 @@ class Chttp2ServerListener : public Server::ListenerInterface {
   grpc_closure tcp_server_shutdown_complete_ ABSL_GUARDED_BY(mu_);
   grpc_closure* on_destroy_done_ ABSL_GUARDED_BY(mu_) = nullptr;
   RefCountedPtr<channelz::ListenSocketNode> channelz_listen_socket_;
-  grpc_resource_quota* resource_quota_;
+  MemoryQuotaRefPtr memory_quota_;
 };
 
 //
@@ -311,14 +310,13 @@ grpc_millis GetConnectionDeadline(const grpc_channel_args* args) {
 Chttp2ServerListener::ActiveConnection::HandshakingState::HandshakingState(
     RefCountedPtr<ActiveConnection> connection_ref,
     grpc_pollset* accepting_pollset, grpc_tcp_server_acceptor* acceptor,
-    grpc_channel_args* args, grpc_resource_user* channel_resource_user)
+    grpc_channel_args* args)
     : connection_(std::move(connection_ref)),
       accepting_pollset_(accepting_pollset),
       acceptor_(acceptor),
       handshake_mgr_(MakeRefCounted<HandshakeManager>()),
       deadline_(GetConnectionDeadline(args)),
-      interested_parties_(grpc_pollset_set_create()),
-      channel_resource_user_(channel_resource_user) {
+      interested_parties_(grpc_pollset_set_create()) {
   grpc_pollset_set_add_pollset(interested_parties_, accepting_pollset_);
   CoreConfiguration::Get().handshaker_registry().AddHandshakers(
       HANDSHAKER_SERVER, args, interested_parties_, handshake_mgr_.get());
@@ -327,9 +325,6 @@ Chttp2ServerListener::ActiveConnection::HandshakingState::HandshakingState(
 Chttp2ServerListener::ActiveConnection::HandshakingState::~HandshakingState() {
   grpc_pollset_set_del_pollset(interested_parties_, accepting_pollset_);
   grpc_pollset_set_destroy(interested_parties_);
-  if (channel_resource_user_ != nullptr) {
-    grpc_resource_user_unref(channel_resource_user_);
-  }
   gpr_free(acceptor_);
 }
 
@@ -414,18 +409,12 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::OnHandshakeDone(
       // handshaker may have handed off the connection to some external
       // code, so we can just clean up here without creating a transport.
       if (args->endpoint != nullptr) {
-        grpc_transport* transport = grpc_create_chttp2_transport(
-            args->args, args->endpoint, false,
-            grpc_resource_user_create(
-                self->connection_->listener_->resource_quota_,
-                absl::StrCat(grpc_endpoint_get_peer(args->endpoint),
-                             ":chttp2_server_transport")));
+        grpc_transport* transport =
+            grpc_create_chttp2_transport(args->args, args->endpoint, false);
         grpc_error_handle channel_init_err =
             self->connection_->listener_->server_->SetupTransport(
                 transport, self->accepting_pollset_, args->args,
-                grpc_chttp2_transport_get_socket_node(transport),
-                self->channel_resource_user_, GRPC_RESOURCE_QUOTA_CHANNEL_SIZE);
-        self->channel_resource_user_ = nullptr;
+                grpc_chttp2_transport_get_socket_node(transport));
         if (channel_init_err == GRPC_ERROR_NONE) {
           // Use notify_on_receive_settings callback to enforce the
           // handshake deadline.
@@ -489,10 +478,6 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::OnHandshakeDone(
   gpr_free(self->acceptor_);
   self->acceptor_ = nullptr;
   OrphanablePtr<ActiveConnection> connection;
-  if (self->channel_resource_user_ != nullptr) {
-    grpc_resource_user_free(self->channel_resource_user_,
-                            GRPC_RESOURCE_QUOTA_CHANNEL_SIZE);
-  }
   if (cleanup_connection) {
     MutexLock listener_lock(&self->connection_->listener_->mu_);
     auto it = self->connection_->listener_->connections_.find(
@@ -511,9 +496,9 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::OnHandshakeDone(
 
 Chttp2ServerListener::ActiveConnection::ActiveConnection(
     grpc_pollset* accepting_pollset, grpc_tcp_server_acceptor* acceptor,
-    grpc_channel_args* args, grpc_resource_user* channel_resource_user)
-    : handshaking_state_(MakeOrphanable<HandshakingState>(
-          Ref(), accepting_pollset, acceptor, args, channel_resource_user)) {
+    grpc_channel_args* args, MemoryOwner memory_owner)
+    : handshaking_state_(memory_owner.MakeOrphanable<HandshakingState>(
+          Ref(), accepting_pollset, acceptor, args)) {
   GRPC_CLOSURE_INIT(&on_close_, ActiveConnection::OnClose, this,
                     grpc_schedule_on_exec_ctx);
 }
@@ -598,14 +583,9 @@ grpc_error_handle Chttp2ServerListener::Create(
   grpc_error_handle error = [&]() {
     grpc_error_handle error = GRPC_ERROR_NONE;
     // Create Chttp2ServerListener.
-    listener = new Chttp2ServerListener(
-        server, args, args_modifier,
-        grpc_resource_quota_from_channel_args(args, true));
-    grpc_resource_quota_ref_internal(listener->resource_quota_);
-    error = grpc_tcp_server_create(
-        &listener->tcp_server_shutdown_complete_, args,
-        grpc_slice_allocator_factory_create(listener->resource_quota_),
-        &listener->tcp_server_);
+    listener = new Chttp2ServerListener(server, args, args_modifier);
+    error = grpc_tcp_server_create(&listener->tcp_server_shutdown_complete_,
+                                   args, &listener->tcp_server_);
     if (error != GRPC_ERROR_NONE) return error;
     if (server->config_fetcher() != nullptr) {
       listener->resolved_address_ = *addr;
@@ -646,14 +626,10 @@ grpc_error_handle Chttp2ServerListener::Create(
 grpc_error_handle Chttp2ServerListener::CreateWithAcceptor(
     Server* server, const char* name, grpc_channel_args* args,
     Chttp2ServerArgsModifier args_modifier) {
-  Chttp2ServerListener* listener = new Chttp2ServerListener(
-      server, args, args_modifier,
-      grpc_resource_quota_from_channel_args(args, true));
-  grpc_resource_quota_ref_internal(listener->resource_quota_);
+  Chttp2ServerListener* listener =
+      new Chttp2ServerListener(server, args, args_modifier);
   grpc_error_handle error = grpc_tcp_server_create(
-      &listener->tcp_server_shutdown_complete_, args,
-      grpc_slice_allocator_factory_create(listener->resource_quota_),
-      &listener->tcp_server_);
+      &listener->tcp_server_shutdown_complete_, args, &listener->tcp_server_);
   if (error != GRPC_ERROR_NONE) {
     delete listener;
     return error;
@@ -668,11 +644,11 @@ grpc_error_handle Chttp2ServerListener::CreateWithAcceptor(
 
 Chttp2ServerListener::Chttp2ServerListener(
     Server* server, grpc_channel_args* args,
-    Chttp2ServerArgsModifier args_modifier, grpc_resource_quota* resource_quota)
+    Chttp2ServerArgsModifier args_modifier)
     : server_(server),
       args_modifier_(args_modifier),
       args_(args),
-      resource_quota_(resource_quota) {
+      memory_quota_(ResourceQuotaFromChannelArgs(args)->memory_quota()) {
   GRPC_CLOSURE_INIT(&tcp_server_shutdown_complete_, TcpServerShutdownComplete,
                     this, grpc_schedule_on_exec_ctx);
 }
@@ -685,7 +661,6 @@ Chttp2ServerListener::~Chttp2ServerListener() {
     ExecCtx::Run(DEBUG_LOCATION, on_destroy_done_, GRPC_ERROR_NONE);
     ExecCtx::Get()->Flush();
   }
-  grpc_resource_quota_unref_internal(resource_quota_);
   grpc_channel_args_destroy(args_);
 }
 
@@ -764,11 +739,10 @@ void Chttp2ServerListener::OnAccept(void* arg, grpc_endpoint* tcp,
     }
     args_to_destroy = args;
   }
-  grpc_resource_user* channel_resource_user = grpc_resource_user_create(
-      self->resource_quota_,
+  auto memory_owner = self->memory_quota_->CreateMemoryOwner(
       absl::StrCat(grpc_endpoint_get_peer(tcp), ":server_channel"));
-  auto connection = MakeOrphanable<ActiveConnection>(
-      accepting_pollset, acceptor, args, channel_resource_user);
+  auto connection = memory_owner.MakeOrphanable<ActiveConnection>(
+      accepting_pollset, acceptor, args, std::move(memory_owner));
   // We no longer own acceptor
   acceptor = nullptr;
   // Hold a ref to connection to allow starting handshake outside the
@@ -779,20 +753,13 @@ void Chttp2ServerListener::OnAccept(void* arg, grpc_endpoint* tcp,
     MutexLock lock(&self->mu_);
     // Shutdown the the connection if listener's stopped serving.
     if (!self->shutdown_ && self->is_serving_) {
-      if (!grpc_resource_user_safe_alloc(channel_resource_user,
-                                         GRPC_RESOURCE_QUOTA_CHANNEL_SIZE)) {
-        gpr_log(
-            GPR_INFO,
-            "Memory quota exhausted, rejecting connection, no handshaking.");
-      } else {
-        // This ref needs to be taken in the critical region after having made
-        // sure that the listener has not been Orphaned, so as to avoid
-        // heap-use-after-free issues where `Ref()` is invoked when the ref of
-        // tcp_server_ has already reached 0. (Ref() implementation of
-        // Chttp2ServerListener is grpc_tcp_server_ref().)
-        listener_ref = self->Ref();
-        self->connections_.emplace(connection.get(), std::move(connection));
-      }
+      // This ref needs to be taken in the critical region after having made
+      // sure that the listener has not been Orphaned, so as to avoid
+      // heap-use-after-free issues where `Ref()` is invoked when the ref of
+      // tcp_server_ has already reached 0. (Ref() implementation of
+      // Chttp2ServerListener is grpc_tcp_server_ref().)
+      listener_ref = self->Ref();
+      self->connections_.emplace(connection.get(), std::move(connection));
     }
   }
   if (connection != nullptr) {
@@ -849,24 +816,32 @@ grpc_error_handle Chttp2ServerAddPort(Server* server, const char* addr,
                                       grpc_channel_args* args,
                                       Chttp2ServerArgsModifier args_modifier,
                                       int* port_num) {
+  if (addr == nullptr) {
+    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "Invalid address: addr cannot be a nullptr.");
+  }
   if (strncmp(addr, "external:", 9) == 0) {
-    return grpc_core::Chttp2ServerListener::CreateWithAcceptor(
-        server, addr, args, args_modifier);
+    return Chttp2ServerListener::CreateWithAcceptor(server, addr, args,
+                                                    args_modifier);
   }
   *port_num = -1;
   grpc_resolved_addresses* resolved = nullptr;
   std::vector<grpc_error_handle> error_list;
+  std::string parsed_addr = URI::PercentDecode(addr);
+  absl::string_view parsed_addr_unprefixed{parsed_addr};
   // Using lambda to avoid use of goto.
   grpc_error_handle error = [&]() {
     grpc_error_handle error = GRPC_ERROR_NONE;
-    if (absl::StartsWith(addr, kUnixUriPrefix)) {
-      error = grpc_resolve_unix_domain_address(
-          addr + sizeof(kUnixUriPrefix) - 1, &resolved);
-    } else if (absl::StartsWith(addr, kUnixAbstractUriPrefix)) {
-      error = grpc_resolve_unix_abstract_domain_address(
-          addr + sizeof(kUnixAbstractUriPrefix) - 1, &resolved);
+    if (absl::ConsumePrefix(&parsed_addr_unprefixed, kUnixUriPrefix)) {
+      error =
+          grpc_resolve_unix_domain_address(parsed_addr_unprefixed, &resolved);
+    } else if (absl::ConsumePrefix(&parsed_addr_unprefixed,
+                                   kUnixAbstractUriPrefix)) {
+      error = grpc_resolve_unix_abstract_domain_address(parsed_addr_unprefixed,
+                                                        &resolved);
     } else {
-      error = grpc_blocking_resolve_address(addr, "https", &resolved);
+      error = grpc_blocking_resolve_address(parsed_addr.c_str(), "https",
+                                            &resolved);
     }
     if (error != GRPC_ERROR_NONE) return error;
     // Create a listener for each resolved address.
@@ -877,9 +852,9 @@ grpc_error_handle Chttp2ServerAddPort(Server* server, const char* addr,
         grpc_sockaddr_set_port(&resolved->addrs[i], *port_num);
       }
       int port_temp = -1;
-      error = grpc_core::Chttp2ServerListener::Create(
-          server, &resolved->addrs[i], grpc_channel_args_copy(args),
-          args_modifier, &port_temp);
+      error = Chttp2ServerListener::Create(server, &resolved->addrs[i],
+                                           grpc_channel_args_copy(args),
+                                           args_modifier, &port_temp);
       if (error != GRPC_ERROR_NONE) {
         error_list.push_back(error);
       } else {

data/src/core/ext/transport/chttp2/server/insecure/server_chttp2.cc

@@ -40,13 +40,12 @@ int grpc_server_add_insecure_http2_port(grpc_server* server, const char* addr) {
   int port_num = 0;
   GRPC_API_TRACE("grpc_server_add_insecure_http2_port(server=%p, addr=%s)", 2,
                  (server, addr));
+  grpc_core::Server* core_server = grpc_core::Server::FromC(server);
   grpc_error_handle err = grpc_core::Chttp2ServerAddPort(
-      server->core_server.get(), addr,
-      grpc_channel_args_copy(server->core_server->channel_args()),
+      core_server, addr, grpc_channel_args_copy(core_server->channel_args()),
       ModifyArgsForConnection, &port_num);
   if (err != GRPC_ERROR_NONE) {
     gpr_log(GPR_ERROR, "%s", grpc_error_std_string(err).c_str());
-
     GRPC_ERROR_UNREF(err);
   }
   return port_num;

data/src/core/ext/transport/chttp2/server/insecure/server_chttp2_posix.cc

@@ -33,6 +33,7 @@
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/tcp_posix.h"
+#include "src/core/lib/resource_quota/api.h"
 #include "src/core/lib/surface/completion_queue.h"
 #include "src/core/lib/surface/server.h"
 
@@ -41,24 +42,19 @@ void grpc_server_add_insecure_channel_from_fd(grpc_server* server,
   GPR_ASSERT(reserved == nullptr);
 
   grpc_core::ExecCtx exec_ctx;
-  grpc_core::Server* core_server = server->core_server.get();
+  grpc_core::Server* core_server = grpc_core::Server::FromC(server);
 
   const grpc_channel_args* server_args = core_server->channel_args();
   std::string name = absl::StrCat("fd:", fd);
-  grpc_resource_quota* resource_quota =
-      grpc_resource_quota_create(name.c_str());
+  auto memory_quota =
+      grpc_core::ResourceQuotaFromChannelArgs(server_args)->memory_quota();
   grpc_endpoint* server_endpoint = grpc_tcp_create(
-      grpc_fd_create(fd, name.c_str(), true), server_args, name.c_str(),
-      grpc_slice_allocator_create(resource_quota, name, server_args));
+      grpc_fd_create(fd, name.c_str(), true), server_args, name);
   grpc_transport* transport = grpc_create_chttp2_transport(
-      server_args, server_endpoint, false /* is_client */,
-      grpc_resource_user_create(resource_quota,
-                                absl::StrCat(name, ":transport")));
-  grpc_error_handle error = core_server->SetupTransport(
-      transport, nullptr, server_args, nullptr,
-      grpc_resource_user_create(resource_quota,
-                                absl::StrCat(name, ":channel")));
-  grpc_resource_quota_unref_internal(resource_quota);
+      server_args, server_endpoint, false /* is_client */
+  );
+  grpc_error_handle error =
+      core_server->SetupTransport(transport, nullptr, server_args, nullptr);
   if (error == GRPC_ERROR_NONE) {
     for (grpc_pollset* pollset : core_server->pollsets()) {
       grpc_endpoint_add_to_pollset(server_endpoint, pollset);

data/src/core/ext/transport/chttp2/server/secure/server_secure_chttp2.cc

@@ -75,6 +75,7 @@ int grpc_server_add_secure_http2_port(grpc_server* server, const char* addr,
       "grpc_server_add_secure_http2_port("
       "server=%p, addr=%s, creds=%p)",
       3, (server, addr, creds));
+  grpc_core::Server* core_server = grpc_core::Server::FromC(server);
   // Create security context.
   if (creds == nullptr) {
     err = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
@@ -91,10 +92,10 @@ int grpc_server_add_secure_http2_port(grpc_server* server, const char* addr,
   // rewritten, we would be able to make this workaround go away by removing
   // that assumption. As an immediate drawback of this workaround, config
   // fetchers need to be registered before adding ports to the server.
-  if (server->core_server->config_fetcher() != nullptr) {
+  if (core_server->config_fetcher() != nullptr) {
     // Create channel args.
     grpc_arg arg_to_add = grpc_server_credentials_to_arg(creds);
-    args = grpc_channel_args_copy_and_add(server->core_server->channel_args(),
+    args = grpc_channel_args_copy_and_add(core_server->channel_args(),
                                           &arg_to_add, 1);
   } else {
     sc = creds->create_security_connector(nullptr);
@@ -107,12 +108,11 @@ int grpc_server_add_secure_http2_port(grpc_server* server, const char* addr,
     grpc_arg args_to_add[2];
     args_to_add[0] = grpc_server_credentials_to_arg(creds);
     args_to_add[1] = grpc_security_connector_to_arg(sc.get());
-    args = grpc_channel_args_copy_and_add(server->core_server->channel_args(),
-                                          args_to_add,
-                                          GPR_ARRAY_SIZE(args_to_add));
+    args = grpc_channel_args_copy_and_add(
+        core_server->channel_args(), args_to_add, GPR_ARRAY_SIZE(args_to_add));
   }
   // Add server port.
-  err = grpc_core::Chttp2ServerAddPort(server->core_server.get(), addr, args,
+  err = grpc_core::Chttp2ServerAddPort(core_server, addr, args,
                                        ModifyArgsForConnection, &port_num);
 done:
   sc.reset(DEBUG_LOCATION, "server");