grpc 1.84.0 → 1.85.0.pre1

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

@@ -50,7 +50,7 @@ struct CFEventEngine::Closure final : public EventEngine::Closure {
     GRPC_TRACE_LOG(event_engine, INFO)
         << "CFEventEngine:" << engine << " executing callback:" << handle;
     {
-      grpc_core::MutexLock lock(&engine->task_mu_);
+      grpc_core::MutexLock lock(engine->task_mu_);
       engine->known_handles_.erase(handle);
     }
     cb();
@@ -66,7 +66,7 @@ CFEventEngine::CFEventEngine()
 
 CFEventEngine::~CFEventEngine() {
   {
-    grpc_core::MutexLock lock(&task_mu_);
+    grpc_core::MutexLock lock(task_mu_);
     if (GRPC_TRACE_FLAG_ENABLED(event_engine)) {
       for (auto handle : known_handles_) {
         LOG(ERROR) << "CFEventEngine:" << this
@@ -102,7 +102,7 @@ CFEventEngine::ConnectionHandle CFEventEngine::Connect(
 
   ConnectionHandle handle{reinterpret_cast<intptr_t>(endpoint_ptr), 0};
   {
-    grpc_core::MutexLock lock(&conn_mu_);
+    grpc_core::MutexLock lock(conn_mu_);
     conn_handles_.insert(handle);
   }
 
@@ -121,7 +121,7 @@ CFEventEngine::ConnectionHandle CFEventEngine::Connect(
         that->Cancel(deadline_timer);
 
         {
-          grpc_core::MutexLock lock(&that->conn_mu_);
+          grpc_core::MutexLock lock(that->conn_mu_);
           that->conn_handles_.erase(handle);
         }
 
@@ -149,7 +149,7 @@ bool CFEventEngine::CancelConnect(ConnectionHandle handle) {
 
 bool CFEventEngine::CancelConnectInternal(ConnectionHandle handle,
                                           absl::Status status) {
-  grpc_core::MutexLock lock(&conn_mu_);
+  grpc_core::MutexLock lock(conn_mu_);
 
   if (!conn_handles_.contains(handle)) {
     GRPC_TRACE_LOG(event_engine, INFO)
@@ -196,7 +196,7 @@ EventEngine::TaskHandle CFEventEngine::RunAfter(
 }
 
 bool CFEventEngine::Cancel(TaskHandle handle) {
-  grpc_core::MutexLock lock(&task_mu_);
+  grpc_core::MutexLock lock(task_mu_);
   if (!known_handles_.contains(handle)) return false;
   auto* cd = reinterpret_cast<Closure*>(handle.keys[0]);
   bool r = timer_manager_.TimerCancel(&cd->timer);
@@ -213,7 +213,7 @@ EventEngine::TaskHandle CFEventEngine::RunAfterInternal(
   cd->engine = this;
   EventEngine::TaskHandle handle{reinterpret_cast<intptr_t>(cd),
                                  aba_token_.fetch_add(1)};
-  grpc_core::MutexLock lock(&task_mu_);
+  grpc_core::MutexLock lock(task_mu_);
   known_handles_.insert(handle);
   cd->handle = handle;
   GRPC_TRACE_LOG(event_engine, INFO)

data/src/core/lib/event_engine/cf_engine/cfsocket_listener.cc

@@ -63,7 +63,7 @@ void CFSocketListenerImpl::Shutdown() {
   GRPC_TRACE_LOG(event_engine, INFO)
       << "CFSocketListenerImpl::Shutdown: this: " << this;
 
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
 
   shutdown_ = true;
   for (auto& [ipv6cfsock] : ipv6cfsocks_) {
@@ -78,7 +78,7 @@ void CFSocketListenerImpl::Shutdown() {
 
 absl::StatusOr<int> CFSocketListenerImpl::Bind(
     const EventEngine::ResolvedAddress& addr) {
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
 
   if (started_) {
     return absl::FailedPreconditionError(
@@ -160,7 +160,7 @@ absl::StatusOr<int> CFSocketListenerImpl::Bind(
 }
 
 absl::Status CFSocketListenerImpl::Start() {
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
 
   CHECK(!started_);
   started_ = true;
@@ -174,7 +174,7 @@ absl::Status CFSocketListenerImpl::Start() {
         << ", this: " << thatPtr;
 
     {
-      grpc_core::MutexLock lock(&that->mu_);
+      grpc_core::MutexLock lock(that->mu_);
       if (that->shutdown_) {
         return;
       }

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

@@ -66,12 +66,12 @@ void SetEventEngineFactory(
       new absl::AnyInvocable<std::shared_ptr<EventEngine>()>(
           std::move(factory)));
   // Forget any previous factory-created EventEngines
-  grpc_core::MutexLock lock(&*g_mu);
+  grpc_core::MutexLock lock(*g_mu);
   g_default_event_engine->emplace<std::weak_ptr<EventEngine>>();
 }
 
 void EventEngineFactoryReset() {
-  grpc_core::MutexLock lock(&*g_mu);
+  grpc_core::MutexLock lock(*g_mu);
   delete g_event_engine_factory.exchange(nullptr);
   g_default_event_engine->emplace<std::weak_ptr<EventEngine>>();
 }
@@ -90,7 +90,7 @@ std::shared_ptr<EventEngine> CreateEventEngine() {
 }
 
 void SetDefaultEventEngine(std::shared_ptr<EventEngine> engine) {
-  grpc_core::MutexLock lock(&*g_mu);
+  grpc_core::MutexLock lock(*g_mu);
   if (engine == nullptr) {
     // If it's being set to null, switch back to a weak_ptr.
     g_default_event_engine->emplace<std::weak_ptr<EventEngine>>();
@@ -100,7 +100,7 @@ void SetDefaultEventEngine(std::shared_ptr<EventEngine> engine) {
 }
 
 std::shared_ptr<EventEngine> GetDefaultEventEngine() {
-  grpc_core::MutexLock lock(&*g_mu);
+  grpc_core::MutexLock lock(*g_mu);
   auto engine = InternalGetDefaultEventEngineIfAny();
   if (engine != nullptr) return engine;
   engine = CreateEventEngine();
@@ -111,7 +111,7 @@ std::shared_ptr<EventEngine> GetDefaultEventEngine() {
 void ShutdownDefaultEventEngine() {
   std::shared_ptr<EventEngine> tmp_engine;
   {
-    grpc_core::MutexLock lock(&*g_mu);
+    grpc_core::MutexLock lock(*g_mu);
     tmp_engine = InternalGetDefaultEventEngineIfAny();
     g_default_event_engine->emplace<std::weak_ptr<EventEngine>>();
   }

data/src/core/lib/event_engine/posix_engine/ev_epoll1_linux.cc

@@ -200,7 +200,7 @@ void Epoll1EventHandle::OrphanHandle(PosixEngineClosure* on_done,
   {
     // See Epoll1Poller::ShutdownHandle for explanation on why a mutex is
     // required here.
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     read_closure_.DestroyEvent();
     write_closure_.DestroyEvent();
     error_closure_.DestroyEvent();
@@ -209,7 +209,7 @@ void Epoll1EventHandle::OrphanHandle(PosixEngineClosure* on_done,
   pending_write_.store(false, std::memory_order_release);
   pending_error_.store(false, std::memory_order_release);
   {
-    grpc_core::MutexLock lock(&poller_->mu_);
+    grpc_core::MutexLock lock(poller_->mu_);
 #ifdef GRPC_ENABLE_FORK_SUPPORT
     poller_->fork_handles_set_.erase(this);
 #endif  // GRPC_ENABLE_FORK_SUPPORT
@@ -259,7 +259,7 @@ Epoll1Poller::Epoll1Poller(std::shared_ptr<ThreadPool> thread_pool)
 }
 
 void Epoll1Poller::Close() {
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   if (closed_) return;
 
   if (g_epoll_set_.epfd.ready()) {
@@ -283,7 +283,7 @@ EventHandle* Epoll1Poller::CreateHandle(FileDescriptor fd,
                                         bool track_err) {
   Epoll1EventHandle* new_handle = nullptr;
   {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     if (free_epoll1_handles_list_.empty()) {
       new_handle = new Epoll1EventHandle(fd, this);
     } else {
@@ -385,7 +385,7 @@ void Epoll1EventHandle::ShutdownHandle(absl::Status why) {
   // in parallel is not safe because some of the lockfree event types e.g, read,
   // write, error may-not have called SetShutdown when DestroyEvent gets
   // called in the OrphanHandle method.
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   HandleShutdownInternal(why, false);
 }
 
@@ -426,7 +426,7 @@ Poller::WorkResult Epoll1Poller::Work(
     }
   }
   {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     // If was_kicked_ is true, collect all pending events in this iteration.
     if (ProcessEpollEvents(
             was_kicked_ ? INT_MAX : MAX_EPOLL_EVENTS_HANDLED_PER_ITERATION,
@@ -448,7 +448,7 @@ Poller::WorkResult Epoll1Poller::Work(
 }
 
 void Epoll1Poller::Kick() {
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   if (was_kicked_ || closed_) {
     return;
   }
@@ -465,7 +465,7 @@ void Epoll1Poller::HandleForkInChild() {
     posix_interface().AdvanceGeneration();
   }
   {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     for (EventHandle* handle : fork_handles_set_) {
       handle->ShutdownHandle(absl::CancelledError("Closed on fork"));
     }
@@ -489,7 +489,7 @@ void Epoll1Poller::ResetKickState() {
   auto status = posix_interface().EpollCtlAdd(
       g_epoll_set_.epfd, false, wakeup_fd_->ReadFd(), wakeup_fd_.get());
   GRPC_CHECK(status.ok()) << status.StrError();
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   was_kicked_ = false;
 }
 

data/src/core/lib/event_engine/posix_engine/ev_poll_posix.cc

@@ -35,6 +35,7 @@
 #include "src/core/util/grpc_check.h"
 #include "absl/container/inlined_vector.h"
 #include "absl/functional/any_invocable.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_format.h"
@@ -86,7 +87,7 @@ class PollEventHandle : public EventHandle {
         read_closure_(reinterpret_cast<PosixEngineClosure*>(kClosureNotReady)),
         write_closure_(
             reinterpret_cast<PosixEngineClosure*>(kClosureNotReady)) {
-    grpc_core::MutexLock lock(&poller_->mu_);
+    grpc_core::MutexLock lock(poller_->mu_);
     poller_->PollerHandlesListAddHandle(this);
   }
   PollPoller* Poller() override { return poller_.get(); }
@@ -104,7 +105,7 @@ class PollEventHandle : public EventHandle {
     return false;
   }
   void ForceRemoveHandleFromPoller() {
-    grpc_core::MutexLock lock(&poller_->mu_);
+    grpc_core::MutexLock lock(poller_->mu_);
     poller_->PollerHandlesListRemoveHandle(this);
   }
   FileDescriptor WrappedFd() override { return fd_; }
@@ -141,13 +142,13 @@ class PollEventHandle : public EventHandle {
   void SetWritable() override;
   void SetHasError() override;
   bool IsHandleShutdown() override {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     return is_shutdown_;
   };
   inline void ExecutePendingActions() {
     int kick = 0;
     {
-      grpc_core::MutexLock lock(&mu_);
+      grpc_core::MutexLock lock(mu_);
       if ((pending_actions_ & 1UL)) {
         if (SetReadyLocked(&read_closure_)) {
           kick = 1;
@@ -333,7 +334,7 @@ void PollEventHandle::ShutdownHandle(absl::Status why) {
   // of a closure which calls OrphanHandle or poller->Shutdown() prematurely.
   Ref();
   {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     // only shutdown once
     if (!is_shutdown_) {
       is_shutdown_ = true;
@@ -402,7 +403,7 @@ void PollEventHandle::NotifyOnError(PosixEngineClosure* on_error) {
 void PollEventHandle::SetReadable() {
   Ref();
   {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     SetReadyLocked(&read_closure_);
   }
   Unref();
@@ -411,7 +412,7 @@ void PollEventHandle::SetReadable() {
 void PollEventHandle::SetWritable() {
   Ref();
   {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     SetReadyLocked(&write_closure_);
   }
   Unref();
@@ -455,7 +456,7 @@ bool PollEventHandle::EndPollLocked(bool got_read, bool got_write) {
 }
 
 void PollPoller::KickExternal(bool ext) {
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   if (closed_) {
     return;
   }
@@ -565,7 +566,7 @@ Poller::WorkResult PollPoller::Work(
     PollEventHandle* head = poll_handles_list_head_;
     while (head != nullptr) {
       {
-        grpc_core::MutexLock lock(head->mu());
+        grpc_core::MutexLock lock(*head->mu());
         // There shouldn't be any orphaned fds at this point. This is because
         // prior to marking a handle as orphaned it is first removed from
         // poll handle list for the poller under the poller lock.
@@ -584,8 +585,9 @@ Poller::WorkResult PollPoller::Work(
             pfds[pfd_count].events = head->BeginPollLocked(POLLIN, POLLOUT);
             pfd_count++;
           } else {
-            LOG(INFO) << "FD from fork parent still in poll list: "
-                      << head->WrappedFd();
+            LOG_EVERY_N_SEC(INFO, 10)
+                << "FD from fork parent still in poll list: "
+                << head->WrappedFd();
           }
         }
       }
@@ -715,7 +717,7 @@ Poller::WorkResult PollPoller::Work(
 }
 
 void PollPoller::Close() {
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   closed_ = true;
 }
 
@@ -726,7 +728,7 @@ void PollPoller::HandleForkInChild() {
   }
   PollEventHandle* handle;
   {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     handle = poll_handles_list_head_;
   }
   while (handle != nullptr) {
@@ -742,7 +744,7 @@ void PollPoller::ResetKickState() {
   // new fd
   // TODO (eostroukhov): Need to consider merging kicked/kicked_ext
   // with the wakeup_fd so there's no duplicate state.
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   was_kicked_ = false;
   was_kicked_ext_ = false;
 }

data/src/core/lib/event_engine/posix_engine/file_descriptor_collection.cc

@@ -35,7 +35,7 @@ FileDescriptorCollection::FileDescriptorCollection(int generation) noexcept
 FileDescriptorCollection::FileDescriptorCollection(
     FileDescriptorCollection&& other) noexcept
     : generation_(other.generation_) {
-  grpc_core::MutexLock lock(&other.mu_);
+  grpc_core::MutexLock lock(other.mu_);
   file_descriptors_ = std::move(other.file_descriptors_);
   other.generation_ = -1;
   other.file_descriptors_.clear();
@@ -44,8 +44,8 @@ FileDescriptorCollection::FileDescriptorCollection(
 FileDescriptorCollection& FileDescriptorCollection::operator=(
     FileDescriptorCollection&& other) noexcept {
   generation_ = other.generation_;
-  grpc_core::MutexLock self_lock(&mu_);
-  grpc_core::MutexLock other_lock(&other.mu_);
+  grpc_core::MutexLock self_lock(mu_);
+  grpc_core::MutexLock other_lock(other.mu_);
   file_descriptors_ = std::move(other.file_descriptors_);
   other.generation_ = -1;
   other.file_descriptors_.clear();
@@ -54,7 +54,7 @@ FileDescriptorCollection& FileDescriptorCollection::operator=(
 
 FileDescriptor FileDescriptorCollection::Add(int fd) {
   if (IsForkEnabled()) {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     file_descriptors_.emplace(fd);
   }
   return FileDescriptor(fd, generation_);
@@ -65,7 +65,7 @@ bool FileDescriptorCollection::Remove(const FileDescriptor& fd) {
     return true;
   }
   if (fd.generation() == generation_) {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     return file_descriptors_.erase(fd.fd()) == 1;
   }
   return false;
@@ -76,7 +76,7 @@ FileDescriptorCollection::ClearAndReturnRawDescriptors() {
   if (!IsForkEnabled()) {
     return {};
   }
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   absl::flat_hash_set<int> file_descriptors = std::move(file_descriptors_);
   // Should not be necessary, but standard is not clear if move would empty
   // the collection

data/src/core/lib/event_engine/posix_engine/grpc_polled_fd_posix.h

@@ -106,7 +106,7 @@ class GrpcPolledFdFactoryPosix : public GrpcPolledFdFactory {
       : poller_(poller) {}
 
   ~GrpcPolledFdFactoryPosix() override {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     for (auto& fd : owned_fds_) {
       close(fd);
     }
@@ -116,7 +116,7 @@ class GrpcPolledFdFactoryPosix : public GrpcPolledFdFactory {
 
   std::unique_ptr<GrpcPolledFd> NewGrpcPolledFdLocked(
       ares_socket_t as) override {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     owned_fds_.insert(as);
     CHECK_NE(poller_, nullptr);
     FileDescriptor fd(as, poller_->posix_interface().generation());
@@ -165,7 +165,7 @@ class GrpcPolledFdFactoryPosix : public GrpcPolledFdFactory {
   static int Close(ares_socket_t as, void* user_data) {
     GrpcPolledFdFactoryPosix* self =
         static_cast<GrpcPolledFdFactoryPosix*>(user_data);
-    grpc_core::MutexLock lock(&self->mu_);
+    grpc_core::MutexLock lock(self->mu_);
     if (self->owned_fds_.find(as) == self->owned_fds_.end()) {
       // c-ares owns this fd, grpc has never seen it
       return close(as);

data/src/core/lib/event_engine/posix_engine/posix_endpoint.cc

@@ -607,7 +607,7 @@ void PosixEndpointImpl::HandleRead(absl::Status status) {
   bool ret = false;
   absl::AnyInvocable<void(absl::Status)> cb = nullptr;
   grpc_core::EnsureRunInExecCtx([&, this]() mutable {
-    grpc_core::MutexLock lock(&read_mu_);
+    grpc_core::MutexLock lock(read_mu_);
     ret = HandleReadLocked(status);
     if (ret) {
       GRPC_TRACE_LOG(event_engine_endpoint, INFO)

data/src/core/lib/event_engine/posix_engine/posix_endpoint.h

@@ -214,7 +214,7 @@ class TcpZerocopySendCtx {
   void NoteSend(TcpZerocopySendRecord* record) {
     record->Ref();
     {
-      grpc_core::MutexLock lock(&mu_);
+      grpc_core::MutexLock lock(mu_);
       is_in_write_ = true;
       AssociateSeqWithSendRecordLocked(last_send_, record);
     }
@@ -246,7 +246,7 @@ class TcpZerocopySendCtx {
 
   // Get a send record for a send that we wish to do with zerocopy.
   TcpZerocopySendRecord* GetSendRecord() {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     return TryGetSendRecordLocked();
   }
 
@@ -260,7 +260,7 @@ class TcpZerocopySendCtx {
   // buffers for this sendmsg()) is received from the kernel - or, in case
   // sendmsg() was unsuccessful to begin with.
   TcpZerocopySendRecord* ReleaseSendRecord(uint32_t seq) {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     return ReleaseSendRecordLocked(seq);
   }
 
@@ -269,7 +269,7 @@ class TcpZerocopySendCtx {
   // max_sends_ tcp_write() instances with zerocopy enabled in flight at the
   // same time.
   void PutSendRecord(TcpZerocopySendRecord* record) {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     GRPC_DCHECK(record >= send_records_ && record < send_records_ + max_sends_);
     PutSendRecordLocked(record);
   }
@@ -281,7 +281,7 @@ class TcpZerocopySendCtx {
   // Indicates that there are no inflight tcp_write() instances with zerocopy
   // enabled.
   bool AllSendRecordsEmpty() {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     return free_send_records_size_ == max_sends_;
   }
 
@@ -322,7 +322,7 @@ class TcpZerocopySendCtx {
   // Please refer to the STATE TRANSITION DIAGRAM below for more details.
   //
   bool UpdateZeroCopyOptMemStateAfterFree() {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     if (is_in_write_) {
       zcopy_enobuf_state_ = OptMemState::kCheck;
       return false;
@@ -362,7 +362,7 @@ class TcpZerocopySendCtx {
   // Please refer to the STATE TRANSITION DIAGRAM below for more details.
   //
   bool UpdateZeroCopyOptMemStateAfterSend(bool seen_enobuf, bool& constrained) {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     is_in_write_ = false;
     constrained = false;
     if (seen_enobuf) {

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

@@ -103,7 +103,7 @@ absl::NoDestructor<absl::InlinedVector<ForkHandlerPointers<std::weak_ptr>, 16>>
 // "Locks" event engines and returns a collection so callbacks can be invoked
 // without holding a lock.
 std::vector<ForkHandlerPointers<std::shared_ptr>> LockForkHandlers() {
-  grpc_core::MutexLock lock(fork_mu.get());
+  grpc_core::MutexLock lock(*fork_mu);
   std::vector<ForkHandlerPointers<std::shared_ptr>> locked;
   // Not all weak_ptrs might be locked. If an engine enters dtor, it will stop
   // on a mutex in DeregisterEventEngineForFork but the weak pointer will not
@@ -168,7 +168,7 @@ void RegisterEventEngineForFork(
   if (!(grpc_core::Fork::Enabled())) {
     return;
   }
-  grpc_core::MutexLock lock(fork_mu.get());
+  grpc_core::MutexLock lock(*fork_mu);
   // We have mutex, cleanup if there's any expired event engines
   fork_handlers->erase(
       std::remove_if(fork_handlers->begin(), fork_handlers->end(),
@@ -212,14 +212,14 @@ PosixEventEngine::PollingCycle::PollingCycle(
 PosixEventEngine::PollingCycle::~PollingCycle() {
   done_ = true;
   poller_->Kick();
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   while (is_scheduled_ > 0) {
     cond_.Wait(&mu_);
   }
 }
 
 void PosixEventEngine::PollingCycle::PollerWorkInternal() {
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   --is_scheduled_;
   GRPC_CHECK_EQ(is_scheduled_, 0);
   bool again = false;
@@ -253,7 +253,7 @@ AsyncConnect::~AsyncConnect() { delete on_writable_; }
 void AsyncConnect::OnTimeoutExpired(absl::Status status) {
   bool done = false;
   {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     if (fd_ != nullptr) {
       fd_->ShutdownHandle(std::move(status));
     }
@@ -391,7 +391,7 @@ void PosixEventEngine::OnConnectFinishInternal(int connection_handle) {
   int shard_number = connection_handle % connection_shards_.size();
   struct ConnectionShard* shard = &connection_shards_[shard_number];
   {
-    grpc_core::MutexLock lock(&shard->mu);
+    grpc_core::MutexLock lock(shard->mu);
     shard->pending_connections.erase(connection_handle);
   }
 }
@@ -442,7 +442,7 @@ struct PosixEventEngine::ClosureData final : public EventEngine::Closure {
     GRPC_TRACE_LOG(event_engine, INFO)
         << "PosixEventEngine:" << engine << " executing callback:" << handle;
     {
-      grpc_core::MutexLock lock(&engine->mu_);
+      grpc_core::MutexLock lock(engine->mu_);
       engine->known_handles_.erase(handle);
     }
     cb();
@@ -452,7 +452,7 @@ struct PosixEventEngine::ClosureData final : public EventEngine::Closure {
 
 void PosixEventEngine::CancelAllPendingTimers() {
   {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     auto pending_handles = known_handles_;
     for (auto handle : pending_handles) {
       CancelInternal(handle);
@@ -465,7 +465,7 @@ void PosixEventEngine::CancelAllPendingTimers() {
 
 PosixEventEngine::~PosixEventEngine() {
   {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     auto pending_handles = known_handles_;
     for (auto handle : pending_handles) {
       if (GRPC_TRACE_FLAG_ENABLED(event_engine)) {
@@ -487,7 +487,7 @@ PosixEventEngine::~PosixEventEngine() {
 }
 
 bool PosixEventEngine::Cancel(EventEngine::TaskHandle handle) {
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   return CancelInternal(handle);
 }
 
@@ -530,7 +530,7 @@ EventEngine::TaskHandle PosixEventEngine::RunAfterInternal(
   cd->engine = this;
   EventEngine::TaskHandle handle{reinterpret_cast<intptr_t>(cd),
                                  aba_token_.fetch_add(1)};
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   if (disallow_new_timers_) {
     delete cd;
     // Return handle and don't schedule the callback. The caller will see a
@@ -571,7 +571,7 @@ void PosixEventEngine::PosixDNSResolver::LookupTXT(LookupTXTCallback on_resolve,
 void PosixEventEngine::RegisterAresResolverForFork(
     GRPC_UNUSED AresResolver* resolver) {
 #if GRPC_ENABLE_FORK_SUPPORT && GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK
-  grpc_core::MutexLock lock(&resolver_handles_mu_);
+  grpc_core::MutexLock lock(resolver_handles_mu_);
   resolver_handles_.emplace_back(resolver->GetReinitHandle());
   // Cleanup in case we have expired callbacks, prevents the list from
   // growing indefinitely
@@ -662,7 +662,7 @@ bool PosixEventEngine::CancelConnect(EventEngine::ConnectionHandle handle) {
   struct ConnectionShard* shard = &connection_shards_[shard_number];
   AsyncConnect* ac = nullptr;
   {
-    grpc_core::MutexLock lock(&shard->mu);
+    grpc_core::MutexLock lock(shard->mu);
     auto it = shard->pending_connections.find(connection_handle);
     if (it != shard->pending_connections.end()) {
       ac = it->second;
@@ -817,7 +817,7 @@ PosixEventEngine::CreateEndpointFromUnconnectedFdInternal(
   int shard_number = connection_id % connection_shards_.size();
   struct ConnectionShard* shard = &connection_shards_[shard_number];
   {
-    grpc_core::MutexLock lock(&shard->mu);
+    grpc_core::MutexLock lock(shard->mu);
     shard->pending_connections.insert_or_assign(connection_id, ac);
   }
   // Start asynchronous connect and return the connection id.
@@ -874,13 +874,13 @@ void PosixEventEngine::SchedulePoller() {
   if (poller_ == nullptr) {
     return;
   }
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   GRPC_CHECK(!polling_cycle_.has_value());
   polling_cycle_.emplace(executor_, poller_);
 }
 
 void PosixEventEngine::ResetPollCycle() {
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   polling_cycle_.reset();
 }
 
@@ -970,7 +970,7 @@ void PosixEventEngine::AfterForkInChild() {
     }
   };
   {
-    grpc_core::MutexLock lock(&resolver_handles_mu_);
+    grpc_core::MutexLock lock(resolver_handles_mu_);
     for (const auto& cb : resolver_handles_) {
       auto locked = cb.lock();
       if (locked != nullptr) {

data/src/core/lib/event_engine/posix_engine/posix_engine_listener.cc

@@ -70,7 +70,7 @@ PosixEngineListenerImpl::PosixEngineListenerImpl(
 absl::StatusOr<int> PosixEngineListenerImpl::Bind(
     const EventEngine::ResolvedAddress& addr,
     PosixListenerWithFdSupport::OnPosixBindNewFdCallback on_bind_new_fd) {
-  grpc_core::MutexLock lock(&this->mu_);
+  grpc_core::MutexLock lock(this->mu_);
   if (this->started_) {
     return absl::FailedPreconditionError(
         "Listener is already started, ports can no longer be bound");
@@ -307,7 +307,7 @@ void PosixEngineListenerImpl::AsyncConnectionAcceptor::Shutdown() {
 }
 
 absl::Status PosixEngineListenerImpl::Start() {
-  grpc_core::MutexLock lock(&this->mu_);
+  grpc_core::MutexLock lock(this->mu_);
   // Start each asynchronous acceptor.
   GRPC_CHECK(!this->started_);
   this->started_ = true;
@@ -320,7 +320,7 @@ absl::Status PosixEngineListenerImpl::Start() {
 void PosixEngineListenerImpl::TriggerShutdown() {
   // This would get invoked from the destructor of the parent
   // PosixEngineListener object.
-  grpc_core::MutexLock lock(&this->mu_);
+  grpc_core::MutexLock lock(this->mu_);
   for (auto it = acceptors_.begin(); it != acceptors_.end(); it++) {
     // Trigger shutdown of each asynchronous acceptor. This in-turn calls
     // ShutdownHandle on the associated poller event handle. It may also