grpc 1.48.0-x86_64-linux → 1.49.0.pre1-x86_64-linux

data/src/core/lib/resource_quota/memory_quota.h

@@ -34,11 +34,19 @@
 #include <grpc/event_engine/memory_request.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/gprpp/global_config_generic.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/poll.h"
+#include "src/core/lib/resource_quota/periodic_update.h"
+
+GPR_GLOBAL_CONFIG_DECLARE_BOOL(grpc_experimental_smooth_memory_presure);
+GPR_GLOBAL_CONFIG_DECLARE_BOOL(
+    grpc_experimental_enable_periodic_resource_quota_reclamation);
+GPR_GLOBAL_CONFIG_DECLARE_INT32(grpc_experimental_max_quota_buffer_size);
 
 namespace grpc_core {
 
@@ -80,7 +88,6 @@ enum class ReclamationPass {
   kDestructive = 3,
 };
 static constexpr size_t kNumReclamationPasses = 4;
-static constexpr size_t kMaxQuotaBufferSize = 1024 * 1024;
 
 // For each reclamation function run we construct a ReclamationSweep.
 // When this object is finally destroyed (it may be moved several times first),
@@ -220,9 +227,72 @@ class ReclaimerQueue {
   std::shared_ptr<State> state_;
 };
 
+namespace memory_quota_detail {
+// Controller: tries to adjust a control variable up or down to get memory
+// pressure to some target. We use the control variable to size buffers
+// throughout the stack.
+class PressureController {
+ public:
+  PressureController(uint8_t max_ticks_same, uint8_t max_reduction_per_tick)
+      : max_ticks_same_(max_ticks_same),
+        max_reduction_per_tick_(max_reduction_per_tick) {}
+  // Update the controller, returns the new control value.
+  double Update(double error);
+  // Textual representation of the controller.
+  std::string DebugString() const;
+
+ private:
+  // How many update periods have we reached the same decision in a row?
+  // Too many and we should start expanding the search space since we're not
+  // being agressive enough.
+  uint8_t ticks_same_ = 0;
+  // Maximum number of ticks with the same value until we start expanding the
+  // control space.
+  const uint8_t max_ticks_same_;
+  // Maximum amount to reduce the reporting value per iteration (in tenths of a
+  // percentile).
+  const uint8_t max_reduction_per_tick_;
+  // Was the last error indicating a too low pressure (or if false,
+  // a too high pressure).
+  bool last_was_low_ = true;
+  // Current minimum value to report.
+  double min_ = 0.0;
+  // Current maximum value to report.
+  // Set so that the first change over will choose 1.0 for max.
+  double max_ = 2.0;
+  // Last control value reported.
+  double last_control_ = 0.0;
+};
+
+// Utility to track memory pressure.
+// Tries to be conservative (returns a higher pressure than there may actually
+// be) but to be eventually accurate.
+class PressureTracker {
+ public:
+  double AddSampleAndGetControlValue(double sample);
+
+ private:
+  std::atomic<double> max_this_round_{0.0};
+  std::atomic<double> report_{0.0};
+  PeriodicUpdate update_{Duration::Seconds(1)};
+  PressureController controller_{100, 3};
+};
+}  // namespace memory_quota_detail
+
 class BasicMemoryQuota final
     : public std::enable_shared_from_this<BasicMemoryQuota> {
  public:
+  // Data about current memory pressure.
+  struct PressureInfo {
+    // The current instantaneously measured memory pressure.
+    double instantaneous_pressure;
+    // A control value that can be used to scale buffer sizes up or down to
+    // adjust memory pressure to our target set point.
+    double pressure_control_value;
+    // Maximum recommended individual allocation size.
+    size_t max_recommended_allocation_size;
+  };
+
   explicit BasicMemoryQuota(std::string name) : name_(std::move(name)) {}
 
   // Start the reclamation activity.
@@ -243,8 +313,7 @@ class BasicMemoryQuota final
   // Return some memory to the quota.
   void Return(size_t amount);
   // Instantaneous memory pressure approximation.
-  std::pair<double, size_t>
-  InstantaneousPressureAndMaxRecommendedAllocationSize() const;
+  PressureInfo GetPressureInfo();
   // Get a reclamation queue
   ReclaimerQueue* reclaimer_queue(size_t i) { return &reclaimers_[i]; }
 
@@ -276,6 +345,8 @@ class BasicMemoryQuota final
   // We also increment this counter on completion of a sweep, as an indicator
   // that the wait has ended.
   std::atomic<uint64_t> reclamation_counter_{0};
+  // Memory pressure smoothing
+  memory_quota_detail::PressureTracker pressure_tracker_;
   // The name of this quota - used for debugging/tracing/etc..
   std::string name_;
 };
@@ -299,7 +370,9 @@ class GrpcMemoryAllocatorImpl final : public EventEngineMemoryAllocatorImpl {
     // from  0 to non-zero, then we have more to do, otherwise, we're actually
     // done.
     size_t prev_free = free_bytes_.fetch_add(n, std::memory_order_release);
-    if (prev_free + n > kMaxQuotaBufferSize) {
+    if ((max_quota_buffer_size() > 0 &&
+         prev_free + n > max_quota_buffer_size()) ||
+        (periodic_donate_back() && donate_back_.Tick([](Duration) {}))) {
       // Try to immediately return some free'ed memory back to the total quota.
       MaybeDonateBack();
     }
@@ -319,22 +392,28 @@ class GrpcMemoryAllocatorImpl final : public EventEngineMemoryAllocatorImpl {
   void Shutdown() override;
 
   // Read the instantaneous memory pressure
-  double InstantaneousPressure() const {
-    return memory_quota_->InstantaneousPressureAndMaxRecommendedAllocationSize()
-        .first;
+  BasicMemoryQuota::PressureInfo GetPressureInfo() const {
+    return memory_quota_->GetPressureInfo();
   }
 
   // Name of this allocator
   absl::string_view name() const { return name_; }
 
  private:
+  static bool periodic_donate_back() {
+    static const bool value = GPR_GLOBAL_CONFIG_GET(
+        grpc_experimental_enable_periodic_resource_quota_reclamation);
+    return value;
+  }
+  static size_t max_quota_buffer_size() {
+    static const size_t value =
+        GPR_GLOBAL_CONFIG_GET(grpc_experimental_max_quota_buffer_size);
+    return value;
+  }
   // Primitive reservation function.
   absl::optional<size_t> TryReserve(MemoryRequest request) GRPC_MUST_USE_RESULT;
-  // This function may be invoked during a memory release operation. If the
-  // total free_bytes in this allocator/local cache exceeds
-  // kMaxQuotaBufferSize / 2, donate the excess free_bytes in this cache back
-  // to the total quota immediately. This helps prevent free bytes in any
-  // particular allocator from growing too large.
+  // This function may be invoked during a memory release operation.
+  // It will try to return half of our free pool to the quota.
   void MaybeDonateBack();
   // Replenish bytes from the quota, without blocking, possibly entering
   // overcommit.
@@ -359,6 +438,8 @@ class GrpcMemoryAllocatorImpl final : public EventEngineMemoryAllocatorImpl {
   // Amount of memory taken from the quota by this allocator.
   std::atomic<size_t> taken_bytes_{sizeof(GrpcMemoryAllocatorImpl)};
   std::atomic<bool> registered_reclaimer_{false};
+  // We try to donate back some memory periodically to the central quota.
+  PeriodicUpdate donate_back_{Duration::Seconds(10)};
   Mutex reclaimer_mu_;
   bool shutdown_ ABSL_GUARDED_BY(reclaimer_mu_) = false;
   // Indices into the various reclaimer queues, used so that we can cancel
@@ -392,8 +473,8 @@ class MemoryOwner final : public MemoryAllocator {
   }
 
   // Instantaneous memory pressure in the underlying quota.
-  double InstantaneousPressure() const {
-    return impl()->InstantaneousPressure();
+  BasicMemoryQuota::PressureInfo GetPressureInfo() const {
+    return impl()->GetPressureInfo();
   }
 
   template <typename T, typename... Args>
@@ -442,9 +523,9 @@ class MemoryQuota final
 
   // Return true if the instantaneous memory pressure is high.
   bool IsMemoryPressureHigh() const {
-    static constexpr double kMemoryPressureHighThreshold = 0.9;
-    return memory_quota_->InstantaneousPressureAndMaxRecommendedAllocationSize()
-               .first > kMemoryPressureHighThreshold;
+    static constexpr double kMemoryPressureHighThreshold = 1.0;
+    return memory_quota_->GetPressureInfo().instantaneous_pressure >
+           kMemoryPressureHighThreshold;
   }
 
  private:

data/src/core/lib/resource_quota/periodic_update.cc

@@ -0,0 +1,79 @@
+// Copyright 2022 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/resource_quota/periodic_update.h"
+
+#include <atomic>
+
+#include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+
+namespace grpc_core {
+
+bool PeriodicUpdate::MaybeEndPeriod(absl::FunctionRef<void(Duration)> f) {
+  if (period_start_ == Timestamp::ProcessEpoch()) {
+    period_start_ = ExecCtx::Get()->Now();
+    updates_remaining_.store(1, std::memory_order_release);
+    return false;
+  }
+  // updates_remaining_ just reached 0 and the thread calling this function was
+  // the decrementer that got us there.
+  // We can now safely mutate any non-atomic mutable variables (we've got a
+  // guarantee that no other thread will), and by the time this function returns
+  // we must store a postive number into updates_remaining_.
+  auto now = ExecCtx::Get()->Now();
+  Duration time_so_far = now - period_start_;
+  if (time_so_far < period_) {
+    // At most double the number of updates remaining until the next period.
+    // At least try to estimate when we'll reach it.
+    int64_t better_guess;
+    if (time_so_far.millis() == 0) {
+      better_guess = expected_updates_per_period_ * 2;
+    } else {
+      // Determine a scaling factor that would have gotten us to the next
+      // period, but clamp between 1.01 (at least 1% increase in guesses)
+      // and 2.0 (at most doubling) - to avoid running completely out of
+      // control.
+      const double scale =
+          Clamp(period_.seconds() / time_so_far.seconds(), 1.01, 2.0);
+      better_guess = expected_updates_per_period_ * scale;
+      if (better_guess <= expected_updates_per_period_) {
+        better_guess = expected_updates_per_period_ + 1;
+      }
+    }
+    // Store the remainder left. Note that updates_remaining_ may have been
+    // decremented by another thread whilst we performed the above calculations:
+    // we simply discard those decrements.
+    updates_remaining_.store(better_guess - expected_updates_per_period_,
+                             std::memory_order_release);
+    // Not quite done, return, try for longer.
+    return false;
+  }
+  // Finished period, start a new one and return true.
+  // We try to predict how many update periods we'd need to cover the full time
+  // span, and we increase that by 1% to attempt to tend to not enter the above
+  // stanza.
+  expected_updates_per_period_ =
+      period_.seconds() * expected_updates_per_period_ / time_so_far.seconds();
+  if (expected_updates_per_period_ < 1) expected_updates_per_period_ = 1;
+  period_start_ = now;
+  f(time_so_far);
+  updates_remaining_.store(expected_updates_per_period_,
+                           std::memory_order_release);
+  return true;
+}
+
+}  // namespace grpc_core

data/src/core/lib/resource_quota/periodic_update.h

@@ -0,0 +1,71 @@
+// Copyright 2022 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_LIB_RESOURCE_QUOTA_PERIODIC_UPDATE_H
+#define GRPC_CORE_LIB_RESOURCE_QUOTA_PERIODIC_UPDATE_H
+
+#include <grpc/support/port_platform.h>
+
+#include <inttypes.h>
+
+#include <atomic>
+
+#include "absl/functional/function_ref.h"
+
+#include "src/core/lib/gprpp/time.h"
+
+namespace grpc_core {
+
+// Lightweight timer-like mechanism for periodic updates.
+// Fast path only decrements an atomic int64.
+// Slow path runs corrections and estimates how many ticks are required to hit
+// the target period.
+// This is super inaccurate of course, but for places where we can't run timers,
+// or places where continuous registration/unregistration would cause problems
+// it can be quite useful.
+class PeriodicUpdate {
+ public:
+  explicit PeriodicUpdate(Duration period) : period_(period) {}
+
+  // Tick the update, call f and return true if we think the period expired.
+  bool Tick(absl::FunctionRef<void(Duration)> f) {
+    // Atomically decrement the remaining ticks counter.
+    // If we hit 0 our estimate of period length has expired.
+    // See the comment next to the data members for a description of thread
+    // safety.
+    if (updates_remaining_.fetch_sub(1, std::memory_order_acquire) == 1) {
+      return MaybeEndPeriod(f);
+    }
+    return false;
+  }
+
+ private:
+  bool MaybeEndPeriod(absl::FunctionRef<void(Duration)> f);
+
+  // Thread safety:
+  // When updates_remaining_ reaches 0 the thread that decremented becomes
+  // responsible for updating any mutable variables and then setting
+  // updates_remaining_ to a value greater than zero.
+  // Whilst in this state other threads *may* decrement updates_remaining_, but
+  // this is fine because they'll observe an ignorable negative value.
+
+  std::atomic<int64_t> updates_remaining_{1};
+  const Duration period_;
+  Timestamp period_start_ = Timestamp::ProcessEpoch();
+  int64_t expected_updates_per_period_ = 1;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_RESOURCE_QUOTA_PERIODIC_UPDATE_H

data/src/core/lib/security/authorization/evaluate_args.cc

@@ -16,6 +16,9 @@
 
 #include "src/core/lib/security/authorization/evaluate_args.h"
 
+#include <string.h>
+
+#include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/match.h"
 #include "absl/strings/numbers.h"
@@ -25,7 +28,6 @@
 
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/gprpp/host_port.h"
-#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/security/credentials/tls/tls_utils.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/uri/uri_parser.h"
@@ -54,13 +56,14 @@ EvaluateArgs::PerChannelArgs::Address ParseEndpointUri(
             std::string(port_view).c_str());
   }
   address.address_str = std::string(host_view);
-  grpc_error_handle error = grpc_string_to_sockaddr(
-      &address.address, address.address_str.c_str(), address.port);
-  if (!GRPC_ERROR_IS_NONE(error)) {
-    gpr_log(GPR_DEBUG, "Address %s is not IPv4/IPv6. Error: %s",
-            address.address_str.c_str(), grpc_error_std_string(error).c_str());
+  auto resolved_address = StringToSockaddr(uri->path());
+  if (!resolved_address.ok()) {
+    gpr_log(GPR_DEBUG, "Address \"%s\" is not IPv4/IPv6. Error: %s",
+            uri->path().c_str(), resolved_address.status().ToString().c_str());
+    memset(&address.address, 0, sizeof(address.address));
+  } else {
+    address.address = *resolved_address;
   }
-  GRPC_ERROR_UNREF(error);
   return address;
 }
 

data/src/core/lib/security/authorization/grpc_server_authz_filter.cc

@@ -29,7 +29,6 @@
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/promise_based_filter.h"
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/promise/poll.h"
 #include "src/core/lib/promise/promise.h"
 #include "src/core/lib/security/authorization/authorization_engine.h"
 #include "src/core/lib/security/authorization/evaluate_args.h"
@@ -47,7 +46,7 @@ GrpcServerAuthzFilter::GrpcServerAuthzFilter(
       provider_(std::move(provider)) {}
 
 absl::StatusOr<GrpcServerAuthzFilter> GrpcServerAuthzFilter::Create(
-    ChannelArgs args, ChannelFilter::Args) {
+    const ChannelArgs& args, ChannelFilter::Args) {
   auto* auth_context = args.GetObject<grpc_auth_context>();
   auto* provider = args.GetObject<grpc_authorization_policy_provider>();
   if (provider == nullptr) {

data/src/core/lib/security/authorization/grpc_server_authz_filter.h

@@ -38,7 +38,7 @@ class GrpcServerAuthzFilter final : public ChannelFilter {
  public:
   static const grpc_channel_filter kFilterVtable;
 
-  static absl::StatusOr<GrpcServerAuthzFilter> Create(ChannelArgs args,
+  static absl::StatusOr<GrpcServerAuthzFilter> Create(const ChannelArgs& args,
                                                       ChannelFilter::Args);
 
   ArenaPromise<ServerMetadataHandle> MakeCallPromise(

data/src/core/lib/security/authorization/matchers.cc

@@ -16,10 +16,14 @@
 
 #include "src/core/lib/security/authorization/matchers.h"
 
+#include <string.h>
+
 #include <algorithm>
 #include <string>
 
 #include "absl/memory/memory.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
 #include <grpc/grpc_security_constants.h>
@@ -27,7 +31,6 @@
 
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
-#include "src/core/lib/iomgr/error.h"
 
 namespace grpc_core {
 
@@ -150,16 +153,16 @@ bool HeaderAuthorizationMatcher::Matches(const EvaluateArgs& args) const {
 
 IpAuthorizationMatcher::IpAuthorizationMatcher(Type type, Rbac::CidrRange range)
     : type_(type), prefix_len_(range.prefix_len) {
-  grpc_error_handle error =
-      grpc_string_to_sockaddr(&subnet_address_, range.address_prefix.c_str(),
-                              /*port does not matter here*/ 0);
-  if (GRPC_ERROR_IS_NONE(error)) {
-    grpc_sockaddr_mask_bits(&subnet_address_, prefix_len_);
-  } else {
-    gpr_log(GPR_DEBUG, "CidrRange address %s is not IPv4/IPv6. Error: %s",
-            range.address_prefix.c_str(), grpc_error_std_string(error).c_str());
+  auto address =
+      StringToSockaddr(range.address_prefix, 0);  // Port does not matter here.
+  if (!address.ok()) {
+    gpr_log(GPR_DEBUG, "CidrRange address \"%s\" is not IPv4/IPv6. Error: %s",
+            range.address_prefix.c_str(), address.status().ToString().c_str());
+    memset(&subnet_address_, 0, sizeof(subnet_address_));
+    return;
   }
-  GRPC_ERROR_UNREF(error);
+  subnet_address_ = *address;
+  grpc_sockaddr_mask_bits(&subnet_address_, prefix_len_);
 }
 
 bool IpAuthorizationMatcher::Matches(const EvaluateArgs& args) const {

data/src/core/lib/security/authorization/rbac_policy.cc

@@ -17,7 +17,6 @@
 #include "src/core/lib/security/authorization/rbac_policy.h"
 
 #include <algorithm>
-#include <type_traits>
 #include <utility>
 
 #include "absl/memory/memory.h"

data/src/core/lib/security/credentials/alts/alts_credentials.cc

@@ -52,8 +52,7 @@ grpc_alts_credentials::~grpc_alts_credentials() {
 grpc_core::RefCountedPtr<grpc_channel_security_connector>
 grpc_alts_credentials::create_security_connector(
     grpc_core::RefCountedPtr<grpc_call_credentials> call_creds,
-    const char* target_name, const grpc_channel_args* /*args*/,
-    grpc_channel_args** /*new_args*/) {
+    const char* target_name, grpc_core::ChannelArgs* /*args*/) {
   return grpc_alts_channel_security_connector_create(
       this->Ref(), std::move(call_creds), target_name);
 }
@@ -75,7 +74,7 @@ grpc_alts_server_credentials::grpc_alts_server_credentials(
 
 grpc_core::RefCountedPtr<grpc_server_security_connector>
 grpc_alts_server_credentials::create_security_connector(
-    const grpc_channel_args* /* args */) {
+    const grpc_core::ChannelArgs& /* args */) {
   return grpc_alts_server_security_connector_create(this->Ref());
 }
 

data/src/core/lib/security/credentials/alts/alts_credentials.h

@@ -23,8 +23,8 @@
 
 #include <grpc/grpc.h>
 #include <grpc/grpc_security.h>
-#include <grpc/impl/codegen/grpc_types.h>
 
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/unique_type_name.h"
@@ -41,8 +41,7 @@ class grpc_alts_credentials final : public grpc_channel_credentials {
   grpc_core::RefCountedPtr<grpc_channel_security_connector>
   create_security_connector(
       grpc_core::RefCountedPtr<grpc_call_credentials> call_creds,
-      const char* target_name, const grpc_channel_args* args,
-      grpc_channel_args** new_args) override;
+      const char* target_name, grpc_core::ChannelArgs* args) override;
 
   grpc_core::UniqueTypeName type() const override;
 
@@ -69,7 +68,7 @@ class grpc_alts_server_credentials final : public grpc_server_credentials {
   ~grpc_alts_server_credentials() override;
 
   grpc_core::RefCountedPtr<grpc_server_security_connector>
-  create_security_connector(const grpc_channel_args* /* args */) override;
+  create_security_connector(const grpc_core::ChannelArgs& /* args */) override;
 
   grpc_core::UniqueTypeName type() const override;
 

data/src/core/lib/security/credentials/composite/composite_credentials.cc

@@ -31,8 +31,6 @@
 
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/promise/detail/basic_seq.h"
-#include "src/core/lib/promise/poll.h"
 #include "src/core/lib/promise/try_seq.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/transport/transport.h"
@@ -146,18 +144,16 @@ grpc_call_credentials* grpc_composite_call_credentials_create(
 grpc_core::RefCountedPtr<grpc_channel_security_connector>
 grpc_composite_channel_credentials::create_security_connector(
     grpc_core::RefCountedPtr<grpc_call_credentials> call_creds,
-    const char* target, const grpc_channel_args* args,
-    grpc_channel_args** new_args) {
+    const char* target, grpc_core::ChannelArgs* args) {
   GPR_ASSERT(inner_creds_ != nullptr && call_creds_ != nullptr);
   /* If we are passed a call_creds, create a call composite to pass it
      downstream. */
   if (call_creds != nullptr) {
     return inner_creds_->create_security_connector(
         composite_call_credentials_create(call_creds_, std::move(call_creds)),
-        target, args, new_args);
+        target, args);
   } else {
-    return inner_creds_->create_security_connector(call_creds_, target, args,
-                                                   new_args);
+    return inner_creds_->create_security_connector(call_creds_, target, args);
   }
 }
 

data/src/core/lib/security/credentials/composite/composite_credentials.h

@@ -31,7 +31,6 @@
 #include <grpc/grpc.h>
 #include <grpc/grpc_security.h>
 #include <grpc/grpc_security_constants.h>
-#include <grpc/impl/codegen/grpc_types.h>
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/useful.h"
@@ -62,12 +61,11 @@ class grpc_composite_channel_credentials : public grpc_channel_credentials {
   grpc_core::RefCountedPtr<grpc_channel_security_connector>
   create_security_connector(
       grpc_core::RefCountedPtr<grpc_call_credentials> call_creds,
-      const char* target, const grpc_channel_args* args,
-      grpc_channel_args** new_args) override;
+      const char* target, grpc_core::ChannelArgs* args) override;
 
   grpc_core::ChannelArgs update_arguments(
       grpc_core::ChannelArgs args) override {
-    return inner_creds_->update_arguments(args);
+    return inner_creds_->update_arguments(std::move(args));
   }
 
   grpc_core::UniqueTypeName type() const override;

data/src/core/lib/security/credentials/credentials.h

@@ -105,15 +105,12 @@ struct grpc_channel_credentials
     return args1->cmp(args2);
   }
 
-  // Creates a security connector for the channel. May also create new channel
-  // args for the channel to be used in place of the passed in const args if
-  // returned non NULL. In that case the caller is responsible for destroying
-  // new_args after channel creation.
+  // Creates a security connector for the channel. Also updates passed in
+  // channel args for the channel.
   virtual grpc_core::RefCountedPtr<grpc_channel_security_connector>
   create_security_connector(
       grpc_core::RefCountedPtr<grpc_call_credentials> call_creds,
-      const char* target, const grpc_channel_args* args,
-      grpc_channel_args** new_args) = 0;
+      const char* target, grpc_core::ChannelArgs* args) = 0;
 
   // Creates a version of the channel credentials without any attached call
   // credentials. This can be used in order to open a channel to a non-trusted
@@ -125,9 +122,7 @@ struct grpc_channel_credentials
   }
 
   // Allows credentials to optionally modify a parent channel's args.
-  // By default, leave channel args as is. The callee takes ownership
-  // of the passed-in channel args, and the caller takes ownership
-  // of the returned channel args.
+  // By default, leave channel args as is.
   virtual grpc_core::ChannelArgs update_arguments(grpc_core::ChannelArgs args) {
     return args;
   }
@@ -253,6 +248,8 @@ grpc_call_credentials* grpc_md_only_test_credentials_create(
 
 /* --- grpc_server_credentials. --- */
 
+#define GRPC_SERVER_CREDENTIALS_ARG "grpc.internal.server_credentials"
+
 // This type is forward declared as a C struct and we cannot define it as a
 // class. Otherwise, compiler will complain about type mismatch due to
 // -Wmismatched-tags.
@@ -261,9 +258,18 @@ struct grpc_server_credentials
  public:
   ~grpc_server_credentials() override { DestroyProcessor(); }
 
+  static absl::string_view ChannelArgName() {
+    return GRPC_SERVER_CREDENTIALS_ARG;
+  }
+
+  static int ChannelArgsCompare(const grpc_server_credentials* a,
+                                const grpc_server_credentials* b) {
+    return grpc_core::QsortCompare(a, b);
+  }
+
   // Ownership of \a args is not passed.
   virtual grpc_core::RefCountedPtr<grpc_server_security_connector>
-  create_security_connector(const grpc_channel_args* args) = 0;
+  create_security_connector(const grpc_core::ChannelArgs& args) = 0;
 
   virtual grpc_core::UniqueTypeName type() const = 0;
 
@@ -284,8 +290,6 @@ struct grpc_server_credentials
       grpc_auth_metadata_processor();  // Zero-initialize the C struct.
 };
 
-#define GRPC_SERVER_CREDENTIALS_ARG "grpc.server_credentials"
-
 grpc_arg grpc_server_credentials_to_arg(grpc_server_credentials* c);
 grpc_server_credentials* grpc_server_credentials_from_arg(const grpc_arg* arg);
 grpc_server_credentials* grpc_find_server_credentials_in_args(