grpc 1.84.1 → 1.85.0.pre1

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

@@ -115,7 +115,7 @@ void TimerList::TimerInit(Timer* timer, grpc_core::Timestamp deadline,
 #endif
 
   {
-    grpc_core::MutexLock lock(&shard->mu);
+    grpc_core::MutexLock lock(shard->mu);
     timer->pending = true;
     grpc_core::Timestamp now = host_->Now();
     if (deadline <= now) {
@@ -144,7 +144,7 @@ void TimerList::TimerInit(Timer* timer, grpc_core::Timestamp deadline,
   // In that case, the timer will simply have to wait for the next
   // TimerCheck.
   if (is_first_timer) {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     if (deadline < shard->min_deadline) {
       grpc_core::Timestamp old_min_deadline = shard_queue_[0]->min_deadline;
       shard->min_deadline = deadline;
@@ -160,7 +160,7 @@ void TimerList::TimerInit(Timer* timer, grpc_core::Timestamp deadline,
 
 bool TimerList::TimerCancel(Timer* timer) {
   Shard* shard = &shards_[grpc_core::HashPointer(timer, num_shards_)];
-  grpc_core::MutexLock lock(&shard->mu);
+  grpc_core::MutexLock lock(shard->mu);
 
   if (timer->pending) {
     timer->pending = false;
@@ -228,7 +228,7 @@ Timer* TimerList::Shard::PopOne(grpc_core::Timestamp now) {
 void TimerList::Shard::PopTimers(
     grpc_core::Timestamp now, grpc_core::Timestamp* new_min_deadline,
     std::vector<experimental::EventEngine::Closure*>* out) {
-  grpc_core::MutexLock lock(&mu);
+  grpc_core::MutexLock lock(mu);
   while (Timer* timer = PopOne(now)) {
     out->push_back(timer->closure);
   }
@@ -247,7 +247,7 @@ std::vector<experimental::EventEngine::Closure*> TimerList::FindExpiredTimers(
     return done;
   }
 
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
 
   while (shard_queue_[0]->min_deadline < now ||
          (now != grpc_core::Timestamp::InfFuture() &&

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

@@ -45,7 +45,7 @@ void TimerManager::RunSomeTimers(
 // returns true if the thread should continue executing (false if it should
 // shutdown)
 bool TimerManager::WaitUntil(grpc_core::Timestamp next) {
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   if (state_ != TimerManager::State::kRunning) return false;
   // If kicked_ is true at this point, it means there was a kick from the timer
   // system that the timer-manager threads here missed. We cannot trust 'next'
@@ -98,7 +98,7 @@ grpc_core::Timestamp TimerManager::Host::Now() {
 void TimerManager::TimerInit(Timer* timer, grpc_core::Timestamp deadline,
                              experimental::EventEngine::Closure* closure) {
   if (GRPC_TRACE_FLAG_ENABLED(timer)) {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     if (state_ != TimerManager::State::kRunning) {
       LOG(ERROR) << "WARNING: TimerManager::" << this
                  << ": scheduling Closure::" << closure
@@ -119,13 +119,13 @@ TimerManager::~TimerManager() { Shutdown(); }
 void TimerManager::Host::Kick() { timer_manager_->Kick(); }
 
 void TimerManager::Kick() {
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   kicked_ = true;
   cv_wait_.Signal();
 }
 
 void TimerManager::RestartPostFork() {
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   GRPC_CHECK(state_ != TimerManager::State::kRunning);
   GRPC_TRACE_VLOG(timer, 2)
       << "TimerManager::" << this << " restarting after suspend";
@@ -142,7 +142,7 @@ void TimerManager::PostFork() { RestartPostFork(); }
 
 void TimerManager::SuspendOrShutdown(bool shutdown) {
   {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     if (shutdown) {
       // Pool will become shut down whether it was running or suspended
       state_ = TimerManager::State::kShutdown;

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

@@ -210,7 +210,7 @@ void TracedBufferList::AddNewEntry(int32_t seq_no,
   }
   new_elem.last_timestamp_ = grpc_core::Timestamp::Now();
   // new_elem.last_timestamp_ = new_elem.ts_.sendmsg_time.time;
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   list_.push_back(std::move(new_elem));
 }
 
@@ -220,7 +220,7 @@ void TracedBufferList::ProcessTimestamp(struct sock_extended_err* serr,
   absl::Time timestamp = absl::TimeFromTimespec(tss->ts[0]);
   grpc_core::Timestamp core_timestamp = grpc_core::Timestamp::Now();
   auto metrics = ExtractOptStatsFromCmsg(opt_stats);
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   auto it = list_.begin();
   while (it != list_.end()) {
     // The byte number refers to the sequence number of the last byte which this
@@ -273,7 +273,7 @@ void TracedBufferList::Shutdown(
     sink.RecordEvent(EventEngine::Endpoint::WriteEvent::kClosed, absl::Now(),
                      PosixWriteEventSink::ConnectionMetrics());
   }
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   if (list_.empty()) return;
   auto curr_time = absl::Now();
   for (auto it = list_.begin(); it != list_.end(); ++it) {

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

@@ -59,7 +59,7 @@ class TracedBufferList {
                         struct scm_timestamping* tss);
   // The Size() operation is slow and is used only in tests.
   int Size() {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     return list_.size();
   }
   // Cleans the list by calling the callback for each traced buffer in the list

data/src/core/lib/event_engine/thread_pool/thread_count.cc

@@ -63,7 +63,7 @@ size_t LivingThreadCount::WaitForCountChange(size_t desired_threads,
   size_t count;
   auto deadline = absl::Now() + absl::Milliseconds(timeout.millis());
   do {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     count = CountLocked();
     if (count == desired_threads) break;
     cv_.WaitWithDeadline(&mu_, deadline);

data/src/core/lib/event_engine/thread_pool/thread_count.h

@@ -127,12 +127,12 @@ class LivingThreadCount {
 
   AutoThreadCounter MakeAutoThreadCounter() { return AutoThreadCounter(this); };
   void Increment() ABSL_LOCKS_EXCLUDED(mu_) {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     ++living_count_;
     cv_.SignalAll();
   }
   void Decrement() ABSL_LOCKS_EXCLUDED(mu_) {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     --living_count_;
     cv_.SignalAll();
   }
@@ -144,7 +144,7 @@ class LivingThreadCount {
                                      grpc_core::Duration stuck_timeout)
       ABSL_LOCKS_EXCLUDED(mu_);
   size_t count() ABSL_LOCKS_EXCLUDED(mu_) {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     return CountLocked();
   }
 

data/src/core/lib/event_engine/thread_pool/work_stealing_thread_pool.cc

@@ -132,6 +132,15 @@ constexpr grpc_core::Duration kLifeguardMinSleepBetweenChecks{
 // Maximum time the lifeguard thread should sleep between checking for new work.
 constexpr grpc_core::Duration kLifeguardMaxSleepBetweenChecks{
     grpc_core::Duration::Seconds(1)};
+// Minimum time to wait between attempts of creating the lifeguard thread.
+constexpr grpc_core::Duration kLifeguardStartMinSleep{
+    grpc_core::Duration::Milliseconds(15)};
+// Maximum time to wait between attempts of creating the lifeguard thread.
+constexpr grpc_core::Duration kLifeguardStartMaxSleep{
+    grpc_core::Duration::Seconds(1)};
+// Total time before giving up attempting to create the lifeguard thread.
+constexpr grpc_core::Duration kLifeguardStartTimeout{
+    grpc_core::Duration::Seconds(10)};
 constexpr grpc_core::Duration kBlockUntilThreadCountTimeout{
     grpc_core::Duration::Seconds(60)};
 
@@ -194,17 +203,17 @@ void WorkStealingThreadPool::Run(EventEngine::Closure* closure) {
 // -------- WorkStealingThreadPool::TheftRegistry --------
 
 void WorkStealingThreadPool::TheftRegistry::Enroll(WorkQueue* queue) {
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   queues_.emplace(queue);
 }
 
 void WorkStealingThreadPool::TheftRegistry::Unenroll(WorkQueue* queue) {
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   queues_.erase(queue);
 }
 
 EventEngine::Closure* WorkStealingThreadPool::TheftRegistry::StealOne() {
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   EventEngine::Closure* closure;
   for (auto* queue : queues_) {
     closure = queue->PopMostRecent();
@@ -231,7 +240,7 @@ void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Start() {
   for (size_t i = 0; i < reserve_threads_; i++) {
     StartThread();
   }
-  grpc_core::MutexLock lock(&lifeguard_ptr_mu_);
+  grpc_core::MutexLock lock(lifeguard_ptr_mu_);
   lifeguard_ = std::make_unique<Lifeguard>(this);
 }
 
@@ -281,7 +290,7 @@ void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Quiesce() {
   }
   GRPC_CHECK(queue_.Empty());
   quiesced_.store(true, std::memory_order_relaxed);
-  grpc_core::MutexLock lock(&lifeguard_ptr_mu_);
+  grpc_core::MutexLock lock(lifeguard_ptr_mu_);
   lifeguard_.reset();
 }
 
@@ -325,7 +334,7 @@ void WorkStealingThreadPool::WorkStealingThreadPoolImpl::PrepareFork() {
   if (!threads_were_shut_down.ok() && g_log_verbose_failures) {
     DumpStacksAndCrash();
   }
-  grpc_core::MutexLock lock(&lifeguard_ptr_mu_);
+  grpc_core::MutexLock lock(lifeguard_ptr_mu_);
   lifeguard_.reset();
 }
 
@@ -336,18 +345,18 @@ void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Postfork() {
 
 void WorkStealingThreadPool::WorkStealingThreadPoolImpl::TrackThread(
     gpr_thd_id tid) {
-  grpc_core::MutexLock lock(&thd_set_mu_);
+  grpc_core::MutexLock lock(thd_set_mu_);
   thds_.insert(tid);
 }
 
 void WorkStealingThreadPool::WorkStealingThreadPoolImpl::UntrackThread(
     gpr_thd_id tid) {
-  grpc_core::MutexLock lock(&thd_set_mu_);
+  grpc_core::MutexLock lock(thd_set_mu_);
   thds_.erase(tid);
 }
 
 void WorkStealingThreadPool::WorkStealingThreadPoolImpl::DumpStacksAndCrash() {
-  grpc_core::MutexLock lock(&thd_set_mu_);
+  grpc_core::MutexLock lock(thd_set_mu_);
   LOG(ERROR) << "Pool did not quiesce in time, gRPC will not shut down "
                 "cleanly. Dumping all "
              << thds_.size() << " thread stacks.";
@@ -378,15 +387,35 @@ WorkStealingThreadPool::WorkStealingThreadPoolImpl::Lifeguard::Lifeguard(
   // lifeguard_running_ is set early to avoid a quiesce race while the
   // lifeguard is still starting up.
   lifeguard_running_.store(true);
-  grpc_core::Thread(
-      "lifeguard",
-      [](void* arg) {
-        auto* lifeguard = static_cast<Lifeguard*>(arg);
-        lifeguard->LifeguardMain();
-      },
-      this, nullptr,
-      grpc_core::Thread::Options().set_tracked(false).set_joinable(false))
-      .Start();
+
+  grpc_core::BackOff start_backoff(
+      grpc_core::BackOff::Options()
+          .set_initial_backoff(kLifeguardStartMinSleep)
+          .set_max_backoff(kLifeguardStartMaxSleep)
+          .set_multiplier(1.3));
+  grpc_core::Timestamp deadline =
+      grpc_core::Timestamp::Now() + kLifeguardStartTimeout;
+  while (true) {
+    bool success = false;
+    grpc_core::Thread thread(
+        "lifeguard",
+        [](void* arg) {
+          auto* lifeguard = static_cast<Lifeguard*>(arg);
+          lifeguard->LifeguardMain();
+        },
+        this, &success,
+        grpc_core::Thread::Options().set_tracked(false).set_joinable(false));
+    if (success) {
+      thread.Start();
+      break;
+    } else if (grpc_core::Timestamp::Now() > deadline) {
+      grpc_core::Crash("Failed to start lifeguard thread");
+    } else {
+      // Wait until the system/user has sufficient resources to create a thread.
+      absl::SleepFor(
+          absl::Milliseconds(start_backoff.NextAttemptDelay().millis()));
+    }
+  }
 }
 
 void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Lifeguard::
@@ -614,18 +643,18 @@ void WorkStealingThreadPool::ThreadState::FinishDraining() {
 // -------- WorkStealingThreadPool::WorkSignal --------
 
 void WorkStealingThreadPool::WorkSignal::Signal() {
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   cv_.Signal();
 }
 
 void WorkStealingThreadPool::WorkSignal::SignalAll() {
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   cv_.SignalAll();
 }
 
 bool WorkStealingThreadPool::WorkSignal::WaitWithTimeout(
     grpc_core::Duration time) {
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   return cv_.WaitWithTimeout(&mu_, absl::Milliseconds(time.millis()));
 }
 

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

@@ -51,7 +51,7 @@ ThreadyEventEngine::CreateListener(
            std::move(on_accept))](std::unique_ptr<Endpoint> endpoint,
                                   MemoryAllocator memory_allocator) {
         {
-          grpc_core::MutexLock lock(&accept_state->mu_);
+          grpc_core::MutexLock lock(accept_state->mu_);
           ++accept_state->pending_accepts_;
         }
         Asynchronously(
@@ -59,7 +59,7 @@ ThreadyEventEngine::CreateListener(
              memory_allocator = std::move(memory_allocator)]() mutable {
               (*on_accept)(std::move(endpoint), std::move(memory_allocator));
               {
-                grpc_core::MutexLock lock(&accept_state->mu_);
+                grpc_core::MutexLock lock(accept_state->mu_);
                 --accept_state->pending_accepts_;
                 if (accept_state->pending_accepts_ == 0) {
                   accept_state->cv_.Signal();
@@ -72,7 +72,7 @@ ThreadyEventEngine::CreateListener(
         Asynchronously([accept_state, on_shutdown = std::move(on_shutdown),
                         status = std::move(status)]() mutable {
           while (true) {
-            grpc_core::MutexLock lock(&accept_state->mu_);
+            grpc_core::MutexLock lock(accept_state->mu_);
             if (accept_state->pending_accepts_ == 0) {
               break;
             }

data/src/core/lib/event_engine/windows/grpc_polled_fd_windows.cc

@@ -459,7 +459,7 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
   }
 
   void OnTcpConnect() {
-    grpc_core::MutexLock lock(mu_);
+    grpc_core::MutexLock lock(*mu_);
     GRPC_TRACE_LOG(cares_resolver, INFO)
         << "(EventEngine c-ares resolver) fd:" << GetName()
         << " InnerOnTcpConnectLocked pending_register_for_readable:"
@@ -601,7 +601,7 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
   // the entire resolution attempt. Doing so will allow the "inject broken
   // nameserver list" test to pass on Windows.
   void OnIocpReadable() {
-    grpc_core::MutexLock lock(mu_);
+    grpc_core::MutexLock lock(*mu_);
     absl::Status error;
     if (winsocket_->read_info()->result().wsa_error != 0) {
       // WSAEMSGSIZE would be due to receiving more data
@@ -635,7 +635,7 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
   }
 
   void OnIocpWriteable() {
-    grpc_core::MutexLock lock(mu_);
+    grpc_core::MutexLock lock(*mu_);
     GRPC_TRACE_LOG(cares_resolver, INFO)
         << "(EventEngine c-ares resolver) OnIocpWriteableInner. fd:|"
         << GetName() << "|";

data/src/core/lib/event_engine/windows/windows_engine.cc

@@ -117,7 +117,7 @@ void WindowsEventEngine::ConnectionState::OnConnectedCallback::Run() {
       << " has already run. It should only ever run once.";
   bool has_run;
   {
-    grpc_core::MutexLock lock(&connection_state_->mu_);
+    grpc_core::MutexLock lock(connection_state_->mu_);
     has_run = std::exchange(connection_state_->has_run_, true);
   }
   // This could race with the deadline timer. If so, the engine's
@@ -136,7 +136,7 @@ void WindowsEventEngine::ConnectionState::DeadlineTimerCallback::Run() {
       << " has already run. It should only ever run once.";
   bool has_run;
   {
-    grpc_core::MutexLock lock(&connection_state_->mu_);
+    grpc_core::MutexLock lock(connection_state_->mu_);
     has_run = std::exchange(connection_state_->has_run_, true);
   }
   // This could race with the on connected callback. If so, the engine's
@@ -191,7 +191,7 @@ struct WindowsEventEngine::TimerClosure final : public EventEngine::Closure {
     GRPC_TRACE_LOG(event_engine, INFO)
         << "WindowsEventEngine:" << engine << " executing callback:" << handle;
     {
-      grpc_core::MutexLock lock(&engine->task_mu_);
+      grpc_core::MutexLock lock(engine->task_mu_);
       engine->known_handles_.erase(handle);
     }
     cb();
@@ -247,7 +247,7 @@ WindowsEventEngine::~WindowsEventEngine() {
 }
 
 bool WindowsEventEngine::Cancel(EventEngine::TaskHandle handle) {
-  grpc_core::MutexLock lock(&task_mu_);
+  grpc_core::MutexLock lock(task_mu_);
   if (!known_handles_.contains(handle)) return false;
   GRPC_TRACE_LOG(event_engine, INFO)
       << "WindowsEventEngine::" << this << " cancelling " << handle;
@@ -326,7 +326,7 @@ EventEngine::TaskHandle WindowsEventEngine::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)
@@ -390,11 +390,11 @@ void WindowsEventEngine::OnConnectCompleted(
   EventEngine::OnConnectCallback cb;
   {
     // Connection attempt complete!
-    grpc_core::MutexLock lock(&state->mu());
+    grpc_core::MutexLock lock(state->mu());
     // return early if we cannot cancel the connection timeout timer.
     int erased_handles = 0;
     {
-      grpc_core::MutexLock handle_lock(&connection_mu_);
+      grpc_core::MutexLock handle_lock(connection_mu_);
       erased_handles =
           known_connection_handles_.erase(state->connection_handle());
     }
@@ -436,7 +436,7 @@ void WindowsEventEngine::OnDeadlineTimerFired(
   bool cancelled = false;
   EventEngine::OnConnectCallback cb;
   {
-    grpc_core::MutexLock lock(&connection_state->mu());
+    grpc_core::MutexLock lock(connection_state->mu());
     cancelled = CancelConnectFromDeadlineTimer(connection_state.get());
     if (cancelled) cb = connection_state->TakeCallback();
   }
@@ -533,10 +533,10 @@ EventEngine::ConnectionHandle WindowsEventEngine::Connect(
       /*socket=*/iocp_.Watch(sock), address,
       /*memory_allocator=*/std::move(memory_allocator),
       /*on_connect_user_callback=*/std::move(on_connect));
-  grpc_core::MutexLock lock(&connection_state->mu());
+  grpc_core::MutexLock lock(connection_state->mu());
   auto* info = connection_state->socket()->write_info();
   {
-    grpc_core::MutexLock connection_handle_lock(&connection_mu_);
+    grpc_core::MutexLock connection_handle_lock(connection_mu_);
     known_connection_handles_.insert(connection_state->connection_handle());
   }
   connection_state->Start(timeout);
@@ -557,7 +557,7 @@ EventEngine::ConnectionHandle WindowsEventEngine::Connect(
   connection_state->AbortOnConnect();
   int erased_handles = 0;
   {
-    grpc_core::MutexLock connection_handle_lock(&connection_mu_);
+    grpc_core::MutexLock connection_handle_lock(connection_mu_);
     erased_handles =
         known_connection_handles_.erase(connection_state->connection_handle());
   }
@@ -577,7 +577,7 @@ EventEngine::ConnectionHandle WindowsEventEngine::Connect(
        status = GRPC_WSA_ERROR(WSAGetLastError(), "ConnectEx")]() mutable {
     EventEngine::OnConnectCallback cb;
     {
-      grpc_core::MutexLock lock(&connection_state->mu());
+      grpc_core::MutexLock lock(connection_state->mu());
       cb = connection_state->TakeCallback();
     }
     connection_state.reset();
@@ -594,7 +594,7 @@ bool WindowsEventEngine::CancelConnect(EventEngine::ConnectionHandle handle) {
   }
   // Erase the connection handle, which may be unknown
   {
-    grpc_core::MutexLock lock(&connection_mu_);
+    grpc_core::MutexLock lock(connection_mu_);
     if (known_connection_handles_.erase(handle) != 1) {
       GRPC_TRACE_LOG(event_engine, INFO)
           << "Unknown connection handle: " << handle;
@@ -602,7 +602,7 @@ bool WindowsEventEngine::CancelConnect(EventEngine::ConnectionHandle handle) {
     }
   }
   auto* connection_state = reinterpret_cast<ConnectionState*>(handle.keys[0]);
-  grpc_core::MutexLock state_lock(&connection_state->mu());
+  grpc_core::MutexLock state_lock(connection_state->mu());
   // The connection cannot be cancelled if the deadline timer is already firing.
   if (!Cancel(connection_state->timer_handle())) return false;
   // The deadline timer was cancelled, so we must clean up its state.
@@ -615,7 +615,7 @@ bool WindowsEventEngine::CancelConnectFromDeadlineTimer(
     ConnectionState* connection_state) {
   // Erase the connection handle, which is guaranteed to exist.
   {
-    grpc_core::MutexLock lock(&connection_mu_);
+    grpc_core::MutexLock lock(connection_mu_);
     if (known_connection_handles_.erase(
             connection_state->connection_handle()) != 1) {
       return false;

data/src/core/lib/event_engine/windows/windows_listener.cc

@@ -108,7 +108,7 @@ void UnlinkIfUnixDomainSocket(
 
 WindowsEventEngineListener::SinglePortSocketListener::
     ~SinglePortSocketListener() {
-  grpc_core::MutexLock lock(&io_state_->mu);
+  grpc_core::MutexLock lock(io_state_->mu);
   io_state_->listener_socket->Shutdown(DEBUG_LOCATION,
                                        "~SinglePortSocketListener");
   UnlinkIfUnixDomainSocket(listener_sockname());
@@ -143,7 +143,7 @@ WindowsEventEngineListener::SinglePortSocketListener::Create(
 }
 
 absl::Status WindowsEventEngineListener::SinglePortSocketListener::Start() {
-  grpc_core::MutexLock lock(&io_state_->mu);
+  grpc_core::MutexLock lock(io_state_->mu);
   return StartLocked();
 }
 
@@ -337,7 +337,7 @@ absl::StatusOr<int> WindowsEventEngineListener::Bind(
   // Check if this is a  wildcard port, and if so, try to keep the port the same
   // as some previously created listener.
   if (out_port == 0) {
-    grpc_core::MutexLock lock(&port_listeners_mu_);
+    grpc_core::MutexLock lock(port_listeners_mu_);
     for (const auto& port_listener : port_listeners_) {
       tmp_addr = port_listener->listener_sockname();
       out_port = ResolvedAddressGetPort(tmp_addr);
@@ -372,7 +372,7 @@ absl::StatusOr<int> WindowsEventEngineListener::Bind(
 
 absl::Status WindowsEventEngineListener::Start() {
   GRPC_CHECK(!started_.exchange(true));
-  grpc_core::MutexLock lock(&port_listeners_mu_);
+  grpc_core::MutexLock lock(port_listeners_mu_);
   for (auto& port_listener : port_listeners_) {
     GRPC_RETURN_IF_ERROR(port_listener->Start());
   }
@@ -380,7 +380,7 @@ absl::Status WindowsEventEngineListener::Start() {
 }
 
 void WindowsEventEngineListener::Shutdown() {
-  grpc_core::MutexLock lock(&port_listeners_mu_);
+  grpc_core::MutexLock lock(port_listeners_mu_);
   if (std::exchange(listeners_shutdown_, true)) return;
   // Shut down each port listener before destroying this EventEngine::Listener
   for (auto& port_listener : port_listeners_) {
@@ -395,7 +395,7 @@ WindowsEventEngineListener::AddSinglePortSocketListener(
       SinglePortSocketListener::Create(this, sock, addr);
   GRPC_RETURN_IF_ERROR(single_port_listener.status());
   auto* single_port_listener_ptr = single_port_listener->get();
-  grpc_core::MutexLock lock(&port_listeners_mu_);
+  grpc_core::MutexLock lock(port_listeners_mu_);
   port_listeners_.emplace_back(std::move(*single_port_listener));
   if (started_.load()) {
     LOG(ERROR) << "WindowsEventEngineListener::" << this

data/src/core/lib/event_engine/work_queue/basic_work_queue.cc

@@ -25,17 +25,17 @@ namespace grpc_event_engine::experimental {
 BasicWorkQueue::BasicWorkQueue(void* owner) : owner_(owner) {}
 
 bool BasicWorkQueue::Empty() const {
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   return q_.empty();
 }
 
 size_t BasicWorkQueue::Size() const {
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   return q_.size();
 }
 
 EventEngine::Closure* BasicWorkQueue::PopMostRecent() {
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   if (q_.empty()) return nullptr;
   auto tmp = q_.back();
   q_.pop_back();
@@ -43,7 +43,7 @@ EventEngine::Closure* BasicWorkQueue::PopMostRecent() {
 }
 
 EventEngine::Closure* BasicWorkQueue::PopOldest() {
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   if (q_.empty()) return nullptr;
   auto tmp = q_.front();
   q_.pop_front();
@@ -51,12 +51,12 @@ EventEngine::Closure* BasicWorkQueue::PopOldest() {
 }
 
 void BasicWorkQueue::Add(EventEngine::Closure* closure) {
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   q_.push_back(closure);
 }
 
 void BasicWorkQueue::Add(absl::AnyInvocable<void()> invocable) {
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   q_.push_back(SelfDeletingClosure::Create(std::move(invocable)));
 }