grpc 1.84.0 → 1.85.0.pre1

data/src/core/handshaker/security/secure_endpoint.cc

@@ -583,7 +583,7 @@ class FrameProtector : public RefCounted<FrameProtector> {
   // Therefore, any valid plaintext has already been fully delivered, and
   // read_staging_buffer_ contains only unused, leftover memory capacity.
   void ResetReadStagingBuffer() {
-    MutexLock lock(&read_mu_);
+    MutexLock lock(read_mu_);
     CSliceUnref(read_staging_buffer_);
     read_staging_buffer_ = grpc_empty_slice();
   }
@@ -698,7 +698,7 @@ static void on_read(void* user_data, grpc_error_handle error) {
   secure_endpoint* ep = reinterpret_cast<secure_endpoint*>(user_data);
 
   {
-    grpc_core::MutexLock lock(ep->frame_protector.read_mu());
+    grpc_core::MutexLock lock(*ep->frame_protector.read_mu());
     // If we were shut down after this callback was scheduled with OK
     // status but before it was invoked, we need to treat that as an error.
     if (ep->wrapped_ep == nullptr && error.ok()) {
@@ -752,7 +752,7 @@ static void endpoint_write(
   secure_endpoint* ep = reinterpret_cast<secure_endpoint*>(secure_ep);
   tsi_result result;
   {
-    grpc_core::MutexLock lock(ep->frame_protector.write_mu());
+    grpc_core::MutexLock lock(*ep->frame_protector.write_mu());
     result = ep->frame_protector.Protect(slices, args.max_frame_size());
   }
 
@@ -968,7 +968,7 @@ class SecureEndpoint final : public EventEngine::Endpoint,
         {
           // This mutex should not have any contention since we can only have
           // one outstanding Read() at a time.
-          grpc_core::MutexLock lock(&read_settings_mu_);
+          grpc_core::MutexLock lock(read_settings_mu_);
           if (rpc_receive_coalescing_enabled_) {
             // TODO(aananthv): Make required_read_bytes_ a separate field in
             // ReadArgs to avoid confusion between min_progress_size and
@@ -1015,7 +1015,7 @@ class SecureEndpoint final : public EventEngine::Endpoint,
         // If we get a zero length frame, just complete without looking at
         // anything further
         if (data->Length() == 0) return true;
-        grpc_core::MutexLock lock(&write_queue_mu_);
+        grpc_core::MutexLock lock(write_queue_mu_);
         // If there's been a failure observed asynchronously, then fail out with
         // that error.
         if (!writing_.ok()) {
@@ -1054,7 +1054,7 @@ class SecureEndpoint final : public EventEngine::Endpoint,
       }
       // A small write: encrypt inline and write to the socket.
       {
-        grpc_core::MutexLock lock(frame_protector_.write_mu());
+        grpc_core::MutexLock lock(*frame_protector_.write_mu());
         result = frame_protector_.Protect(data->c_slice_buffer(),
                                           args.max_frame_size());
       }
@@ -1088,7 +1088,7 @@ class SecureEndpoint final : public EventEngine::Endpoint,
 
     void EnableRpcReceiveCoalescing() {
       {
-        grpc_core::MutexLock lock(&read_settings_mu_);
+        grpc_core::MutexLock lock(read_settings_mu_);
         rpc_receive_coalescing_enabled_ = true;
       }
       frame_protector_.ResetReadStagingBuffer();
@@ -1099,7 +1099,7 @@ class SecureEndpoint final : public EventEngine::Endpoint,
 
     void DisableRpcReceiveCoalescing() {
       {
-        grpc_core::MutexLock lock(&read_settings_mu_);
+        grpc_core::MutexLock lock(read_settings_mu_);
         rpc_receive_coalescing_enabled_ = false;
       }
     }
@@ -1110,8 +1110,8 @@ class SecureEndpoint final : public EventEngine::Endpoint,
 
     void Shutdown() {
       std::unique_ptr<EventEngine::Endpoint> wrapped_ep;
-      grpc_core::MutexLock write_lock(frame_protector_.write_mu());
-      grpc_core::MutexLock read_lock(frame_protector_.read_mu());
+      grpc_core::MutexLock write_lock(*frame_protector_.write_mu());
+      grpc_core::MutexLock read_lock(*frame_protector_.read_mu());
       wrapped_ep = std::move(wrapped_ep_);
       frame_protector_.Shutdown();
       GRPC_TRACE_LOG(secure_endpoint, INFO)
@@ -1126,7 +1126,7 @@ class SecureEndpoint final : public EventEngine::Endpoint,
    private:
     bool MaybeFinishReadImmediately() {
       GRPC_LATENT_SEE_ALWAYS_ON_SCOPE("secure_endpoint maybe finish read");
-      grpc_core::MutexLock lock(frame_protector_.read_mu());
+      grpc_core::MutexLock lock(*frame_protector_.read_mu());
       // If the read is large, since we got the bytes whilst still calling read,
       // offload the decryption to event engine.
       // That way we can do the decryption off this thread (which is usually
@@ -1159,7 +1159,7 @@ class SecureEndpoint final : public EventEngine::Endpoint,
                                 absl::Status status) {
       GRPC_LATENT_SEE_ALWAYS_ON_SCOPE("secure endpoint finish async read");
       {
-        grpc_core::MutexLock lock(impl->frame_protector_.read_mu());
+        grpc_core::MutexLock lock(*impl->frame_protector_.read_mu());
         if (status.ok() && impl->wrapped_ep_ == nullptr) {
           status = absl::CancelledError("secure endpoint shutdown");
         }
@@ -1191,7 +1191,7 @@ class SecureEndpoint final : public EventEngine::Endpoint,
 
         bool had_source_data = false;
         {
-          grpc_core::MutexLock lock(frame_protector_.read_mu());
+          grpc_core::MutexLock lock(*frame_protector_.read_mu());
           if (status.ok() && wrapped_ep_ == nullptr) {
             status = absl::CancelledError("secure endpoint shutdown");
           } else {

data/src/core/handshaker/security/security_handshaker.cc

@@ -214,7 +214,7 @@ MakeChannelzSecurityFromAuthContext(grpc_auth_context* auth_context) {
 }  // namespace
 
 void SecurityHandshaker::OnPeerCheckedFn(grpc_error_handle error) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   on_peer_checked_ = nullptr;
   if (!error.ok() || is_shutdown_) {
     HandshakeFailedLocked(error);
@@ -408,7 +408,7 @@ void SecurityHandshaker::OnHandshakeNextDoneGrpcWrapper(
     size_t bytes_to_send_size, tsi_handshaker_result* handshaker_result) {
   RefCountedPtr<SecurityHandshaker> h(
       static_cast<SecurityHandshaker*>(user_data));
-  MutexLock lock(&h->mu_);
+  MutexLock lock(h->mu_);
   grpc_error_handle error = h->OnHandshakeNextDoneLocked(
       result, bytes_to_send, bytes_to_send_size, handshaker_result);
   if (!error.ok()) {
@@ -455,7 +455,7 @@ void SecurityHandshaker::OnHandshakeDataReceivedFromPeerFnScheduler(
 }
 
 void SecurityHandshaker::OnHandshakeDataReceivedFromPeerFn(absl::Status error) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   if (!error.ok() || is_shutdown_) {
     HandshakeFailedLocked(
         GRPC_ERROR_CREATE_REFERENCING("Handshake read failed", &error, 1),
@@ -487,7 +487,7 @@ void SecurityHandshaker::OnHandshakeDataSentToPeerFnScheduler(
 }
 
 void SecurityHandshaker::OnHandshakeDataSentToPeerFn(absl::Status error) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   if (!error.ok() || is_shutdown_) {
     HandshakeFailedLocked(
         GRPC_ERROR_CREATE_REFERENCING("Handshake write failed", &error, 1),
@@ -517,7 +517,7 @@ void SecurityHandshaker::OnHandshakeDataSentToPeerFn(absl::Status error) {
 //
 
 void SecurityHandshaker::Shutdown(grpc_error_handle error) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   if (!is_shutdown_) {
     is_shutdown_ = true;
     connector_->cancel_check_peer(on_peer_checked_, std::move(error));
@@ -529,7 +529,7 @@ void SecurityHandshaker::Shutdown(grpc_error_handle error) {
 void SecurityHandshaker::DoHandshake(
     HandshakerArgs* args,
     absl::AnyInvocable<void(absl::Status)> on_handshake_done) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   args_ = args;
   on_handshake_done_ = std::move(on_handshake_done);
   size_t bytes_received_size = MoveReadBufferIntoHandshakeBuffer();

data/src/core/handshaker/tcp_connect/tcp_connect_handshaker.cc

@@ -101,7 +101,7 @@ TCPConnectHandshaker::TCPConnectHandshaker(grpc_pollset_set* pollset_set)
 void TCPConnectHandshaker::Shutdown(absl::Status /*error*/) {
   // TODO(anramach): After migration to EventEngine, cancel the in-progress
   // TCP connection attempt.
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   if (!shutdown_) {
     shutdown_ = true;
     // If we are shutting down while connecting, respond back with
@@ -127,7 +127,7 @@ void TCPConnectHandshaker::DoHandshake(
     return;
   }
   {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     on_handshake_done_ = std::move(on_handshake_done);
   }
   args_ = args;
@@ -135,7 +135,7 @@ void TCPConnectHandshaker::DoHandshake(
       args->args.GetString(GRPC_ARG_TCP_HANDSHAKER_RESOLVED_ADDRESS).value();
   absl::StatusOr<URI> uri = URI::Parse(resolved_address_text);
   if (!uri.ok() || !grpc_parse_uri(*uri, &addr_)) {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     FinishLocked(GRPC_ERROR_CREATE(absl::StrCat(
         "Resolved address in invalid format: ", resolved_address_text)));
     return;
@@ -167,7 +167,7 @@ void TCPConnectHandshaker::Connected(void* arg, grpc_error_handle error) {
   RefCountedPtr<TCPConnectHandshaker> self(
       static_cast<TCPConnectHandshaker*>(arg));
   {
-    MutexLock lock(&self->mu_);
+    MutexLock lock(self->mu_);
     if (!error.ok() || self->shutdown_) {
       if (error.ok()) {
         error = GRPC_ERROR_CREATE("tcp handshaker shutdown");

data/src/core/lib/channel/channel_args.cc

@@ -18,6 +18,7 @@
 
 #include "src/core/lib/channel/channel_args.h"
 
+#include <grpc/grpc.h>
 #include <grpc/impl/channel_arg_names.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/port_platform.h>
@@ -660,6 +661,25 @@ grpc_arg grpc_channel_arg_pointer_create(
   return arg;
 }
 
+static void* channel_args_copy(void* p) {
+  return grpc_channel_args_copy(static_cast<grpc_channel_args*>(p));
+}
+
+static void channel_args_destroy(void* p) {
+  return grpc_channel_args_destroy(static_cast<grpc_channel_args*>(p));
+}
+
+static int channel_args_compare(void* p1, void* p2) {
+  return grpc_channel_args_compare(static_cast<grpc_channel_args*>(p1),
+                                   static_cast<grpc_channel_args*>(p2));
+}
+
+const grpc_arg_pointer_vtable* grpc_channel_args_arg_vtable(void) {
+  static const grpc_arg_pointer_vtable vtable = {
+      channel_args_copy, channel_args_destroy, channel_args_compare};
+  return &vtable;
+}
+
 std::string grpc_channel_args_string(const grpc_channel_args* args) {
   return grpc_core::ChannelArgs::FromC(args).ToString();
 }

data/src/core/lib/channel/channel_args.h

@@ -125,7 +125,7 @@ struct has_channel_args_compare<
 // static int ChannelArgsCompare(const T* a, const T* b);
 template <typename T>
 struct ChannelArgTypeTraits<
-    T, absl::enable_if_t<
+    T, std::enable_if_t<
            !channel_args_detail::IsRawPointerTagged<T>::kValue &&
                (std::is_base_of<RefCounted<channel_args_detail::RefType<T>>,
                                 channel_args_detail::RefType<T>>::value ||
@@ -162,7 +162,7 @@ struct ChannelArgTypeTraits<
 
 template <typename T>
 struct ChannelArgTypeTraits<
-    T, absl::enable_if_t<channel_args_detail::is_shared_ptr<T>::value, void>> {
+    T, std::enable_if_t<channel_args_detail::is_shared_ptr<T>::value, void>> {
   static void* TakeUnownedPointer(T* p) { return p; }
   static const grpc_arg_pointer_vtable* VTable() {
     static const grpc_arg_pointer_vtable tbl = {
@@ -228,9 +228,9 @@ struct GetObjectImpl;
 template <typename T>
 struct GetObjectImpl<
     T,
-    absl::enable_if_t<!ChannelArgPointerShouldBeConst<T>::kValue &&
-                          channel_args_detail::SupportedSharedPtrType<T>::value,
-                      void>> {
+    std::enable_if_t<!ChannelArgPointerShouldBeConst<T>::kValue &&
+                         channel_args_detail::SupportedSharedPtrType<T>::value,
+                     void>> {
   using Result = T*;
   using ReffedResult = std::shared_ptr<T>;
   using StoredType = std::shared_ptr<T>*;
@@ -251,10 +251,10 @@ struct GetObjectImpl<
 // RefCountedPtr
 template <typename T>
 struct GetObjectImpl<
-    T, absl::enable_if_t<
-           !ChannelArgPointerShouldBeConst<T>::kValue &&
-               !channel_args_detail::SupportedSharedPtrType<T>::value,
-           void>> {
+    T,
+    std::enable_if_t<!ChannelArgPointerShouldBeConst<T>::kValue &&
+                         !channel_args_detail::SupportedSharedPtrType<T>::value,
+                     void>> {
   using Result = T*;
   using ReffedResult = RefCountedPtr<T>;
   using StoredType = Result;
@@ -272,10 +272,10 @@ struct GetObjectImpl<
 
 template <typename T>
 struct GetObjectImpl<
-    T, absl::enable_if_t<
-           ChannelArgPointerShouldBeConst<T>::kValue &&
-               !channel_args_detail::SupportedSharedPtrType<T>::value,
-           void>> {
+    T,
+    std::enable_if_t<ChannelArgPointerShouldBeConst<T>::kValue &&
+                         !channel_args_detail::SupportedSharedPtrType<T>::value,
+                     void>> {
   using Result = const T*;
   using ReffedResult = RefCountedPtr<const T>;
   using StoredType = Result;
@@ -454,7 +454,7 @@ class ChannelArgs {
                                        const char* value) const;
   GRPC_MUST_USE_RESULT ChannelArgs Set(grpc_arg arg) const;
   template <typename T>
-  GRPC_MUST_USE_RESULT absl::enable_if_t<
+  GRPC_MUST_USE_RESULT std::enable_if_t<
       std::is_same<const grpc_arg_pointer_vtable*,
                    decltype(ChannelArgTypeTraits<T>::VTable())>::value,
       ChannelArgs>
@@ -465,7 +465,7 @@ class ChannelArgs {
   template <typename T>
   GRPC_MUST_USE_RESULT auto Set(absl::string_view name,
                                 RefCountedPtr<T> value) const
-      -> absl::enable_if_t<
+      -> std::enable_if_t<
           !ChannelArgPointerShouldBeConst<T>::kValue &&
               std::is_same<const grpc_arg_pointer_vtable*,
                            decltype(ChannelArgTypeTraits<
@@ -478,7 +478,7 @@ class ChannelArgs {
   template <typename T>
   GRPC_MUST_USE_RESULT auto Set(absl::string_view name,
                                 RefCountedPtr<const T> value) const
-      -> absl::enable_if_t<
+      -> std::enable_if_t<
           ChannelArgPointerShouldBeConst<T>::kValue &&
               std::is_same<const grpc_arg_pointer_vtable*,
                            decltype(ChannelArgTypeTraits<
@@ -489,7 +489,7 @@ class ChannelArgs {
                       ChannelArgTypeTraits<absl::remove_cvref_t<T>>::VTable()));
   }
   template <typename T>
-  GRPC_MUST_USE_RESULT absl::enable_if_t<
+  GRPC_MUST_USE_RESULT std::enable_if_t<
       std::is_same<
           const grpc_arg_pointer_vtable*,
           decltype(ChannelArgTypeTraits<std::shared_ptr<T>>::VTable())>::value,

data/src/core/lib/channel/promise_based_filter.cc

@@ -105,7 +105,7 @@ class BaseCallData::WeakWakerHandle final : public Wakeable, public Orphanable {
   void Drop(WakeupMask) override { Unref(); }
 
   std::string ActivityDebugTag(WakeupMask) const override {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     return base_ == nullptr ? "<unknown>" : base_->DebugTag();
   }
 
@@ -113,7 +113,7 @@ class BaseCallData::WeakWakerHandle final : public Wakeable, public Orphanable {
   void WakeupGeneric(WakeupMask wakeup_mask) {
     BaseCallData* wakeup_base = nullptr;
     {
-      MutexLock lock(&mu_);
+      MutexLock lock(mu_);
       if (base_ != nullptr) {
         auto* call_stack = base_->call_stack();
         if (call_stack->refcount.refs.RefIfNonZero(DEBUG_LOCATION, "waker")) {

data/src/core/lib/channel/promise_based_filter.h

@@ -1110,16 +1110,16 @@ struct InterceptFinalize<Derived, void (Call::*)(const grpc_call_final_info*,
 };
 
 template <typename Derived>
-absl::enable_if_t<std::is_empty<FilterCallData<Derived>>::value,
-                  FilterCallData<Derived>*>
+std::enable_if_t<std::is_empty<FilterCallData<Derived>>::value,
+                 FilterCallData<Derived>*>
 MakeFilterCall(Derived*) {
   static FilterCallData<Derived> call{nullptr};
   return &call;
 }
 
 template <typename Derived>
-absl::enable_if_t<!std::is_empty<FilterCallData<Derived>>::value,
-                  FilterCallData<Derived>*>
+std::enable_if_t<!std::is_empty<FilterCallData<Derived>>::value,
+                 FilterCallData<Derived>*>
 MakeFilterCall(Derived* derived) {
   return GetContext<Arena>()->ManagedNew<FilterCallData<Derived>>(derived);
 }
@@ -1361,23 +1361,28 @@ class V3InterceptorToV2Bridge : public ChannelFilter, public Interceptor {
                                          [](bool x) { return StatusFlag(x); });
                             });
                       });
-                  call_args.client_to_server_messages->InterceptAndMap(
-                      [initiator, handler,
-                       pipe_owner](MessageHandle message) mutable {
-                        // Step 1: Push the message onto the v3 initiator in
-                        // its activity.
-                        initiator.SpawnPushMessage(std::move(message));
-                        // Step 3: Here in the v2 activity, read the message
-                        // from the inter-activity pipe and return it.
-                        return Map(
-                            pipe_owner->client_to_server_messages.receiver
-                                .Next(),
-                            [](InterActivityPipe<MessageHandle, 1>::NextResult
-                                   message) -> std::optional<MessageHandle> {
-                              if (!message.has_value()) return std::nullopt;
-                              return std::move(*message);
-                            });
-                      });
+                  call_args.client_to_server_messages
+                      ->InterceptAndMapWithHalfClose(
+                          [initiator, handler,
+                           pipe_owner](MessageHandle message) mutable {
+                            // Step 1: Push the message onto the v3 initiator in
+                            // its activity.
+                            initiator.SpawnPushMessage(std::move(message));
+                            // Step 3: Here in the v2 activity, read the message
+                            // from the inter-activity pipe and return it.
+                            return Map(
+                                pipe_owner->client_to_server_messages.receiver
+                                    .Next(),
+                                [](InterActivityPipe<MessageHandle,
+                                                     1>::NextResult message)
+                                    -> std::optional<MessageHandle> {
+                                  if (!message.has_value()) return std::nullopt;
+                                  return std::move(*message);
+                                });
+                          },
+                          [initiator]() mutable {
+                            initiator.SpawnFinishSends();
+                          });
                   // For server initial metadata, we do a similar thing, but
                   // in the opposite direction, and using an inter-activity
                   // latch instead of a pipe:
@@ -1496,8 +1501,42 @@ class V3InterceptorToV2Bridge : public ChannelFilter, public Interceptor {
                         return Seq(
                             next_promise_factory(std::move(call_args)),
                             [handler](ServerMetadataHandle metadata) mutable {
+                              // Hand the v3 handler its own copy of the
+                              // metadata.
+                              //
+                              // On the client side the v2 stack gives us a
+                              // non-owning alias of
+                              // FilterStackCall::recv_trailing_metadata_:
+                              // ClientCallData::PollTrailingMetadata() wraps
+                              // that batch in a handle with a no-op deleter.
+                              // The v3 call runs in its own party, so pushing
+                              // the alias across lets v2-owned memory escape
+                              // the v2 activity.  That is usually harmless,
+                              // since this arm returns Never and only
+                              // completes once the v3 side pushes the metadata
+                              // back.  But if the v2 stack is cancelled,
+                              // ClientCallData destroys this promise and
+                              // propagates the batch straight up to the
+                              // surface without consulting it; the surface
+                              // then Takes/clears the batch while the v3
+                              // interceptor is still reading it.
+                              //
+                              // Copying keeps the two buffers independent.
+                              // Mutations made by the v3 interceptor still
+                              // come back through the latch, and
+                              // ClientCallData::WakeInsideCombiner() copies
+                              // them into recv_trailing_metadata_ because the
+                              // pointers now differ.  Note we copy rather than
+                              // move: moving would leave the v2 batch empty,
+                              // so the cancellation path above would report an
+                              // empty status instead of the transport's.
+                              ServerMetadataHandle md;
+                              if (metadata != nullptr) {
+                                md = Arena::MakePooled<ServerMetadata>(
+                                    metadata->Copy());
+                              }
                               handler.SpawnPushServerTrailingMetadata(
-                                  std::move(metadata));
+                                  std::move(md));
                               // We return a lambda (promise) here instead of
                               // returning `Pending{}` directly to make this
                               // step safe for subsequent polls. During V2 call
@@ -2374,9 +2413,9 @@ struct ChannelFilterWithFlagsMethods {
 //       ChannelArgs channel_args, ChannelFilter::Args filter_args);
 // };
 template <typename F, FilterEndpoint kEndpoint, uint8_t kFlags = 0>
-absl::enable_if_t<std::is_base_of<ChannelFilter, F>::value &&
-                      !std::is_base_of<ImplementChannelFilterTag, F>::value,
-                  grpc_channel_filter>
+std::enable_if_t<std::is_base_of<ChannelFilter, F>::value &&
+                     !std::is_base_of<ImplementChannelFilterTag, F>::value,
+                 grpc_channel_filter>
 MakePromiseBasedFilter() {
   using CallData = promise_filter_detail::CallData<kEndpoint>;
 
@@ -2413,8 +2452,8 @@ MakePromiseBasedFilter() {
 }
 
 template <typename F, FilterEndpoint kEndpoint, uint8_t kFlags = 0>
-absl::enable_if_t<std::is_base_of<ImplementChannelFilterTag, F>::value,
-                  grpc_channel_filter>
+std::enable_if_t<std::is_base_of<ImplementChannelFilterTag, F>::value,
+                 grpc_channel_filter>
 MakePromiseBasedFilter() {
   using CallData = promise_filter_detail::CallData<kEndpoint>;
 

data/src/core/lib/debug/trace_flags.cc

@@ -51,6 +51,7 @@ DebugOnlyTraceFlag work_serializer_trace(false, "work_serializer");
 DebugOnlyTraceFlag ztrace_trace(false, "ztrace");
 TraceFlag api_trace(false, "api");
 TraceFlag apple_polling_trace(false, "apple_polling");
+TraceFlag autosharding_lb_trace(false, "autosharding_lb");
 TraceFlag backend_metric_trace(false, "backend_metric");
 TraceFlag backend_metric_filter_trace(false, "backend_metric_filter");
 TraceFlag bdp_estimator_trace(false, "bdp_estimator");
@@ -138,6 +139,7 @@ const absl::flat_hash_map<std::string, TraceFlag*>& GetAllTraceFlags() {
       absl::flat_hash_map<std::string, TraceFlag*>({
           {"api", &api_trace},
           {"apple_polling", &apple_polling_trace},
+          {"autosharding_lb", &autosharding_lb_trace},
           {"backend_metric", &backend_metric_trace},
           {"backend_metric_filter", &backend_metric_filter_trace},
           {"bdp_estimator", &bdp_estimator_trace},

data/src/core/lib/debug/trace_flags.h

@@ -50,6 +50,7 @@ extern DebugOnlyTraceFlag work_serializer_trace;
 extern DebugOnlyTraceFlag ztrace_trace;
 extern TraceFlag api_trace;
 extern TraceFlag apple_polling_trace;
+extern TraceFlag autosharding_lb_trace;
 extern TraceFlag backend_metric_trace;
 extern TraceFlag backend_metric_filter_trace;
 extern TraceFlag bdp_estimator_trace;

data/src/core/lib/event_engine/ares_resolver.cc

@@ -255,19 +255,19 @@ AresResolver::ReinitHandle::ReinitHandle(AresResolver* resolver)
     : resolver_(resolver) {}
 
 void AresResolver::ReinitHandle::OnResolverGone() {
-  grpc_core::MutexLock lock(&mutex_);
+  grpc_core::MutexLock lock(mutex_);
   resolver_ = nullptr;
 }
 
 void AresResolver::ReinitHandle::Reset(const absl::Status& status) {
-  grpc_core::MutexLock lock(&mutex_);
+  grpc_core::MutexLock lock(mutex_);
   if (resolver_ != nullptr) {
     resolver_->Reset(status);
   }
 }
 
 void AresResolver::ReinitHandle::Restart() {
-  grpc_core::MutexLock lock(&mutex_);
+  grpc_core::MutexLock lock(mutex_);
   if (resolver_ != nullptr) {
     resolver_->Restart();
   }
@@ -323,14 +323,14 @@ void AresResolver::Orphan() {
   // Do this before locking &mutex_ - ensures there will be no deadlock if
   // resolver is being orphaned during fork.
   {
-    grpc_core::MutexLock handle_lock(&reinit_handle_mu_);
+    grpc_core::MutexLock handle_lock(reinit_handle_mu_);
     if (reinit_handle_ != nullptr) {
       reinit_handle_->OnResolverGone();
     }
   }
 #endif
   {
-    grpc_core::MutexLock lock(&mutex_);
+    grpc_core::MutexLock lock(mutex_);
     shutting_down_ = true;
     ShutdownLocked(absl::CancelledError("AresResolver::Orphan"),
                    "resolver orphaned");
@@ -396,7 +396,7 @@ void AresResolver::LookupHostname(
         });
     return;
   }
-  grpc_core::MutexLock lock(&mutex_);
+  grpc_core::MutexLock lock(mutex_);
   callback_map_.emplace(++id_, std::move(callback));
   auto* resolver_arg = new HostnameQueryArg(this, id_, name, port);
   GRPC_CHECK_NE(channel_, nullptr);
@@ -444,7 +444,7 @@ void AresResolver::LookupSRV(
     });
     return;
   }
-  grpc_core::MutexLock lock(&mutex_);
+  grpc_core::MutexLock lock(mutex_);
   callback_map_.emplace(++id_, std::move(callback));
   auto* resolver_arg = new QueryArg(this, id_, host);
   GRPC_CHECK_NE(channel_, nullptr);
@@ -480,7 +480,7 @@ void AresResolver::LookupTXT(
     });
     return;
   }
-  grpc_core::MutexLock lock(&mutex_);
+  grpc_core::MutexLock lock(mutex_);
   callback_map_.emplace(++id_, std::move(callback));
   auto* resolver_arg = new QueryArg(this, id_, host);
   GRPC_CHECK_NE(channel_, nullptr);
@@ -607,7 +607,7 @@ void AresResolver::MaybeStartTimerLocked() {
 }
 
 void AresResolver::OnReadable(FdNode* fd_node, absl::Status status) {
-  grpc_core::MutexLock lock(&mutex_);
+  grpc_core::MutexLock lock(mutex_);
   GRPC_CHECK(fd_node->readable_registered);
   fd_node->readable_registered = false;
   GRPC_TRACE_LOG(cares_resolver, INFO)
@@ -629,7 +629,7 @@ void AresResolver::OnReadable(FdNode* fd_node, absl::Status status) {
 }
 
 void AresResolver::OnWritable(FdNode* fd_node, absl::Status status) {
-  grpc_core::MutexLock lock(&mutex_);
+  grpc_core::MutexLock lock(mutex_);
   GRPC_CHECK(fd_node->writable_registered);
   fd_node->writable_registered = false;
   GRPC_TRACE_LOG(cares_resolver, INFO)
@@ -657,7 +657,7 @@ void AresResolver::OnWritable(FdNode* fd_node, absl::Status status) {
 // For the latter, we use this backup poller. Also see
 // https://github.com/grpc/grpc/pull/17688 description for more details.
 void AresResolver::OnAresBackupPollAlarm() {
-  grpc_core::MutexLock lock(&mutex_);
+  grpc_core::MutexLock lock(mutex_);
   ares_backup_poll_alarm_handle_.reset();
   GRPC_TRACE_LOG(cares_resolver, INFO)
       << "(EventEngine c-ares resolver) request:" << this
@@ -906,7 +906,7 @@ void AresResolver::OnTXTDoneLocked(void* arg, int status, int /*timeouts*/,
 #ifdef GRPC_ENABLE_FORK_SUPPORT
 
 std::weak_ptr<AresResolver::ReinitHandle> AresResolver::GetReinitHandle() {
-  grpc_core::MutexLock lock(&reinit_handle_mu_);
+  grpc_core::MutexLock lock(reinit_handle_mu_);
   if (reinit_handle_ == nullptr) {
     reinit_handle_ = ReinitHandle::New(this);
   }
@@ -918,7 +918,7 @@ void AresResolver::Reset(const absl::Status& reason) {
   if (self == nullptr) {
     return;
   }
-  grpc_core::MutexLock lock(&mutex_);
+  grpc_core::MutexLock lock(mutex_);
   for (auto& [_, callback] : callback_map_) {
     event_engine_->Run(
         [callback = std::move(callback), reason = reason]() mutable {
@@ -934,7 +934,7 @@ void AresResolver::Reset(const absl::Status& reason) {
 }
 
 void AresResolver::Restart() {
-  grpc_core::MutexLock lock(&mutex_);
+  grpc_core::MutexLock lock(mutex_);
   polled_fd_factory_ = polled_fd_factory_->NewEmptyInstance();
   polled_fd_factory_->Initialize(&mutex_, event_engine_.get());
   GRPC_CHECK_EQ(channel_, nullptr);