grpc 1.81.1 → 1.85.0

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

@@ -44,6 +44,7 @@
 #include "src/core/util/crash.h"
 #include "src/core/util/fork.h"
 #include "src/core/util/grpc_check.h"
+#include "src/core/util/strerror.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/useful.h"
 #include "absl/base/no_destructor.h"
@@ -75,14 +76,6 @@ namespace grpc_event_engine::experimental {
 
 namespace {
 
-bool ShouldUsePosixPoller() {
-#if defined(GRPC_PYTHON_BUILD)
-  return grpc_core::IsEventEnginePollerForPythonEnabled();
-#else
-  return true;
-#endif
-}
-
 #if GRPC_ENABLE_FORK_SUPPORT && GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK
 
 // Thread pool can outlive EE but we need to ensure the ordering if both
@@ -110,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
@@ -175,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(),
@@ -219,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;
@@ -255,12 +248,12 @@ void AsyncConnect::Start(EventEngine::Duration timeout) {
   fd_->NotifyOnWrite(on_writable_);
 }
 
-AsyncConnect ::~AsyncConnect() { delete on_writable_; }
+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));
     }
@@ -383,13 +376,13 @@ void AsyncConnect::OnWritable(absl::Status status)
       return;
     case ECONNREFUSED:
       // This error shouldn't happen for anything other than connect().
-      status = absl::FailedPreconditionError(std::strerror(so_error));
+      status = absl::FailedPreconditionError(grpc_core::StrError(so_error));
       break;
     default:
       // We don't really know which syscall triggered the problem here, so
       // punt by reporting getsockopt().
-      status = absl::FailedPreconditionError(
-          absl::StrCat("getsockopt(SO_ERROR): ", std::strerror(so_error)));
+      status = absl::FailedPreconditionError(absl::StrCat(
+          "getsockopt(SO_ERROR): ", grpc_core::StrError(so_error)));
       break;
   }
 }
@@ -398,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);
   }
 }
@@ -433,10 +426,8 @@ PosixEventEngine::PosixEventEngine(const Options& options)
     : connection_shards_(options.connection_shards),
       executor_(MakeThreadPool(options.reserve_threads)),
       timer_manager_(std::make_shared<TimerManager>(executor_)) {
-  if (ShouldUsePosixPoller()) {
-    poller_ = grpc_event_engine::experimental::MakeDefaultPoller(executor_);
-    SchedulePoller();
-  }
+  poller_ = grpc_event_engine::experimental::MakeDefaultPoller(executor_);
+  SchedulePoller();
 }
 
 #endif  // GRPC_POSIX_SOCKET_TCP
@@ -451,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();
@@ -461,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);
@@ -474,14 +465,18 @@ void PosixEventEngine::CancelAllPendingTimers() {
 
 PosixEventEngine::~PosixEventEngine() {
   {
-    grpc_core::MutexLock lock(&mu_);
-    if (GRPC_TRACE_FLAG_ENABLED(event_engine)) {
-      for (auto handle : known_handles_) {
+    grpc_core::MutexLock lock(mu_);
+    auto pending_handles = known_handles_;
+    for (auto handle : pending_handles) {
+      if (GRPC_TRACE_FLAG_ENABLED(event_engine)) {
         LOG(ERROR) << "(event_engine) PosixEventEngine:" << this
                    << " uncleared TaskHandle at shutdown:"
                    << HandleToString(handle);
       }
+      CancelInternal(handle);
     }
+    // Prevent new timers from being scheduled on this EventEngine.
+    disallow_new_timers_ = true;
     GRPC_CHECK(GPR_LIKELY(known_handles_.empty()));
   }
 #if defined(GRPC_POSIX_SOCKET_TCP)
@@ -492,7 +487,7 @@ PosixEventEngine::~PosixEventEngine() {
 }
 
 bool PosixEventEngine::Cancel(EventEngine::TaskHandle handle) {
-  grpc_core::MutexLock lock(&mu_);
+  grpc_core::MutexLock lock(mu_);
   return CancelInternal(handle);
 }
 
@@ -535,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
@@ -576,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
@@ -667,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;
@@ -807,7 +802,7 @@ PosixEventEngine::CreateEndpointFromUnconnectedFdInternal(
     Run([on_connect = std::move(on_connect),
          ep = absl::FailedPreconditionError(absl::StrCat(
              "connect failed: ", "addr: ", addr_uri.value(),
-             " error: ", std::strerror(connect_errno)))]() mutable {
+             " error: ", grpc_core::StrError(connect_errno)))]() mutable {
       on_connect(std::move(ep));
     });
     return EventEngine::ConnectionHandle::kInvalid;
@@ -822,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.
@@ -834,7 +829,7 @@ absl::StatusOr<std::unique_ptr<EventEngine::Endpoint>>
 PosixEventEngine::CreatePosixEndpointFromFd(int fd,
                                             const EndpointConfig& config,
                                             MemoryAllocator memory_allocator) {
-  GRPC_DCHECK_GT(fd, 0);
+  GRPC_DCHECK_GE(fd, 0);
   if (poller_ == nullptr) {
     return absl::FailedPreconditionError("polling is not enabled");
   }
@@ -879,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();
 }
 
@@ -975,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");
@@ -198,7 +198,7 @@ void PosixEngineListenerImpl::AsyncConnectionAcceptor::NotifyOnAccept(
       auto peer_address = posix_interface.PeerAddress(fd.value());
       if (!peer_address.ok()) {
         auto listener_addr_uri = ResolvedAddressToURI(socket_.addr);
-        LOG(ERROR) << "Failed getpeername: " << grpc_core::StrError(errno)
+        LOG(ERROR) << "Failed getpeername: " << peer_address.status()
                    << ". Dropping the connection, and continuing "
                       "to listen on "
                    << (listener_addr_uri.ok() ? *listener_addr_uri
@@ -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

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

@@ -31,6 +31,7 @@
 #include "src/core/util/crash.h"  // IWYU pragma: keep
 #include "src/core/util/grpc_check.h"
 #include "src/core/util/status_helper.h"
+#include "src/core/util/strerror.h"
 #include "absl/cleanup/cleanup.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
@@ -274,7 +275,7 @@ absl::StatusOr<int> ListenerContainerAddAllLocalAddresses(
   }
   if (getifaddrs(&ifa) != 0 || ifa == nullptr) {
     return absl::FailedPreconditionError(
-        absl::StrCat("getifaddrs: ", std::strerror(errno)));
+        absl::StrCat("getifaddrs: ", grpc_core::StrError(errno)));
   }
 
   static const bool is_ipv4_available = [] {

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

@@ -20,9 +20,9 @@
 
 #if defined(GRPC_POSIX_WAKEUP_FD) || defined(GRPC_LINUX_EVENTFD)
 #include <fcntl.h>
+#endif  // defined(GRPC_POSIX_WAKEUP_FD) || defined(GRPC_LINUX_EVENTFD)
 
 #include "src/core/util/strerror.h"
-#endif  // defined(GRPC_POSIX_WAKEUP_FD) || defined(GRPC_LINUX_EVENTFD)
 
 #ifdef GRPC_POSIX_SOCKET
 
@@ -393,7 +393,7 @@ absl::StatusOr<int> InternalCreateDualStackSocket(
       errno = EAFNOSUPPORT;
     }
     // Check if we've got a valid dualstack socket.
-    if (newfd > 0 && SetSocketDualStack(newfd)) {
+    if (newfd >= 0 && SetSocketDualStack(newfd)) {
       dsmode = EventEnginePosixInterface::DSMode::DSMODE_DUALSTACK;
       return newfd;
     }
@@ -473,7 +473,7 @@ void EventEnginePosixInterface::AdvanceGeneration() {
         "Fork support is disabled but AdvanceGeneration was called");
   }
   for (int fd : descriptors_.ClearAndReturnRawDescriptors()) {
-    if (fd > 0) {
+    if (fd >= 0) {
       close(fd);
     }
   }
@@ -736,13 +736,13 @@ absl::StatusOr<int> EventEnginePosixInterface::GetUnusedPort() {
   if (bind(*fd, wild.address(), wild.size()) != 0) {
     close(*fd);
     return absl::FailedPreconditionError(
-        absl::StrCat("bind(GetUnusedPort): ", std::strerror(errno)));
+        absl::StrCat("bind(GetUnusedPort): ", grpc_core::StrError(errno)));
   }
   socklen_t len = wild.size();
   if (getsockname(*fd, const_cast<sockaddr*>(wild.address()), &len) != 0) {
     close(*fd);
-    return absl::FailedPreconditionError(
-        absl::StrCat("getsockname(GetUnusedPort): ", std::strerror(errno)));
+    return absl::FailedPreconditionError(absl::StrCat(
+        "getsockname(GetUnusedPort): ", grpc_core::StrError(errno)));
   }
   close(*fd);
   int port = ResolvedAddressGetPort(wild);
@@ -857,18 +857,18 @@ EventEnginePosixInterface::BindListenerSocket(
     sockaddr_str = absl::StrReplaceAll(*sockaddr_str, {{"\0", "@"}});
     return absl::FailedPreconditionError(
         absl::StrCat("Error in bind for address '", *sockaddr_str,
-                     "': ", std::strerror(errno)));
+                     "': ", grpc_core::StrError(errno)));
   }
   if (listen(f, GetMaxAcceptQueueSize()) < 0) {
     return absl::FailedPreconditionError(
-        absl::StrCat("Error in listen: ", std::strerror(errno)));
+        absl::StrCat("Error in listen: ", grpc_core::StrError(errno)));
   }
   socklen_t len = static_cast<socklen_t>(sizeof(struct sockaddr_storage));
   EventEngine::ResolvedAddress sockname_temp;
   if (getsockname(f, const_cast<sockaddr*>(sockname_temp.address()), &len) <
       0) {
     return absl::FailedPreconditionError(
-        absl::StrCat("Error in getsockname: ", std::strerror(errno)));
+        absl::StrCat("Error in getsockname: ", grpc_core::StrError(errno)));
   }
   return sockname_temp;
 }
@@ -995,7 +995,7 @@ absl::Status EventEnginePosixInterface::PrepareTcpClientSocket(
     const PosixTcpOptions& options) {
   bool close_fd = true;
   auto sock_cleanup = absl::MakeCleanup([&close_fd, &fd]() -> void {
-    if (close_fd && fd > 0) {
+    if (close_fd && fd >= 0) {
       close(fd);
     }
   });

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

@@ -57,7 +57,7 @@ class PosixWriteEventSink {
     std::optional<uint32_t> congestion_window;
     // Slow start threshold in packets.
     std::optional<uint32_t> snd_ssthresh;
-    // Maximum degree of reordering (i.e., maximum number of packets reodered)
+    // Maximum degree of reordering (i.e., maximum number of packets reordered)
     // on the connection.
     std::optional<uint32_t> reordering;
     // Represents the number of recurring retransmissions of the first sequence

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

@@ -84,6 +84,9 @@ PosixTcpOptions TcpOptionsFromEndpointConfig(const EndpointConfig& config) {
       AdjustValue(PosixTcpOptions::kDefaultMaxReadChunksize, 1,
                   PosixTcpOptions::kMaxChunkSize,
                   config.GetInt(GRPC_ARG_TCP_MAX_READ_CHUNK_SIZE));
+  options.tcp_max_read_buffer_size =
+      AdjustValue(PosixTcpOptions::kMaxReadBufferSizeUnset, 1, INT_MAX,
+                  config.GetInt(GRPC_ARG_TCP_MAX_READ_BUFFER_SIZE));
   options.tcp_tx_zerocopy_send_bytes_threshold =
       AdjustValue(PosixTcpOptions::kDefaultSendBytesThreshold, 0, INT_MAX,
                   config.GetInt(GRPC_ARG_TCP_TX_ZEROCOPY_SEND_BYTES_THRESHOLD));

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

@@ -49,6 +49,7 @@ struct PosixTcpOptions {
   static constexpr int kDefaultMaxReadChunksize = 64 * 1024;
   static constexpr int kZerocpTxEnabledDefault = 0;
   static constexpr int kMaxChunkSize = 32 * 1024 * 1024;
+  static constexpr int kMaxReadBufferSizeUnset = -1;
   static constexpr int kDefaultMaxSends = 4;
   static constexpr size_t kDefaultSendBytesThreshold = 16 * 1024;
   // Let the system decide the proper buffer size.
@@ -57,6 +58,7 @@ struct PosixTcpOptions {
   int tcp_read_chunk_size = kDefaultReadChunkSize;
   int tcp_min_read_chunk_size = kDefaultMinReadChunksize;
   int tcp_max_read_chunk_size = kDefaultMaxReadChunksize;
+  int tcp_max_read_buffer_size = kMaxReadBufferSizeUnset;
   int tcp_tx_zerocopy_send_bytes_threshold = kDefaultSendBytesThreshold;
   int tcp_tx_zerocopy_max_simultaneous_sends = kDefaultMaxSends;
   int tcp_receive_buffer_size = kReadBufferSizeUnset;
@@ -127,6 +129,7 @@ struct PosixTcpOptions {
     tcp_read_chunk_size = other.tcp_read_chunk_size;
     tcp_min_read_chunk_size = other.tcp_min_read_chunk_size;
     tcp_max_read_chunk_size = other.tcp_max_read_chunk_size;
+    tcp_max_read_buffer_size = other.tcp_max_read_buffer_size;
     tcp_tx_zerocopy_send_bytes_threshold =
         other.tcp_tx_zerocopy_send_bytes_threshold;
     tcp_tx_zerocopy_max_simultaneous_sends =

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/shim.cc

@@ -21,14 +21,10 @@
 
 namespace grpc_event_engine::experimental {
 
-bool UseEventEngineClient() {
-  return !EventEngineExperimentDisabledForPython() &&
-         grpc_core::IsEventEngineClientEnabled();
-}
+bool UseEventEngineClient() { return grpc_core::IsEventEngineClientEnabled(); }
 
 bool UseEventEngineListener() {
-  return !EventEngineExperimentDisabledForPython() &&
-         grpc_core::IsEventEngineListenerEnabled();
+  return grpc_core::IsEventEngineListenerEnabled();
 }
 
 bool UsePollsetAlternative() {
@@ -36,14 +32,4 @@ bool UsePollsetAlternative() {
          grpc_core::IsPollsetAlternativeEnabled();
 }
 
-// Returns true if the poller is disabled by build configuration or experiment
-// flags.
-bool EventEngineExperimentDisabledForPython() {
-#ifdef GRPC_PYTHON_BUILD
-  return !grpc_core::IsEventEnginePollerForPythonEnabled();
-#else
-  return false;
-#endif
-}
-
 }  // namespace grpc_event_engine::experimental

data/src/core/lib/event_engine/shim.h

@@ -35,10 +35,6 @@ bool UseEventEngineListener();
 // may disable the poller in some builds.
 bool UsePollsetAlternative();
 
-// Returns true if the poller is disabled by build configuration or experiment
-// flags.
-bool EventEngineExperimentDisabledForPython();
-
 }  // namespace grpc_event_engine::experimental
 
 #endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_SHIM_H

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();
   }