grpc 1.73.0 → 1.74.0

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

@@ -17,6 +17,7 @@
 #include <utility>
 
 #include "absl/strings/str_cat.h"
+#include "src/core/lib/event_engine/posix_engine/posix_interface.h"
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/util/crash.h"  // IWYU pragma: keep
 
@@ -37,59 +38,58 @@ namespace grpc_event_engine::experimental {
 #ifdef GRPC_LINUX_EVENTFD
 
 absl::Status EventFdWakeupFd::Init() {
-  int read_fd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
-  int write_fd = -1;
-  if (read_fd < 0) {
+  auto read_fd = posix_interface_->EventFd(0, EFD_NONBLOCK | EFD_CLOEXEC);
+  if (!read_fd.ok()) {
     return absl::Status(absl::StatusCode::kInternal,
                         absl::StrCat("eventfd: ", grpc_core::StrError(errno)));
   }
-  SetWakeupFds(read_fd, write_fd);
+  SetWakeupFds(read_fd.value(), FileDescriptor::Invalid());
   return absl::OkStatus();
 }
 
 absl::Status EventFdWakeupFd::ConsumeWakeup() {
-  eventfd_t value;
-  int err;
+  PosixError err;
   do {
-    err = eventfd_read(ReadFd(), &value);
-  } while (err < 0 && errno == EINTR);
-  if (err < 0 && errno != EAGAIN) {
-    return absl::Status(
-        absl::StatusCode::kInternal,
-        absl::StrCat("eventfd_read: ", grpc_core::StrError(errno)));
+    err = posix_interface_->EventFdRead(ReadFd());
+  } while (err.IsPosixError(EINTR));
+  if (!err.ok() && !err.IsPosixError(EAGAIN)) {
+    return absl::Status(absl::StatusCode::kInternal,
+                        absl::StrCat("eventfd_read: ", err.StrError()));
   }
   return absl::OkStatus();
 }
 
 absl::Status EventFdWakeupFd::Wakeup() {
-  int err;
+  PosixError err;
   do {
-    err = eventfd_write(ReadFd(), 1);
-  } while (err < 0 && errno == EINTR);
-  if (err < 0) {
-    return absl::Status(
-        absl::StatusCode::kInternal,
-        absl::StrCat("eventfd_write: ", grpc_core::StrError(errno)));
+    err = posix_interface_->EventFdWrite(ReadFd());
+  } while (err.IsPosixError(EINTR));
+  if (!err.ok()) {
+    return absl::Status(absl::StatusCode::kInternal,
+                        absl::StrCat("eventfd_write: ", err.StrError()));
   }
   return absl::OkStatus();
 }
 
 EventFdWakeupFd::~EventFdWakeupFd() {
-  if (ReadFd() != 0) {
-    close(ReadFd());
+  if (ReadFd().ready()) {
+    posix_interface_->Close(ReadFd());
   }
 }
 
 bool EventFdWakeupFd::IsSupported() {
-  EventFdWakeupFd event_fd_wakeup_fd;
+  EventEnginePosixInterface posix_interface;
+  EventFdWakeupFd event_fd_wakeup_fd(&posix_interface);
   return event_fd_wakeup_fd.Init().ok();
 }
 
 absl::StatusOr<std::unique_ptr<WakeupFd>>
-EventFdWakeupFd::CreateEventFdWakeupFd() {
+EventFdWakeupFd::CreateEventFdWakeupFd(
+    EventEnginePosixInterface* posix_interface) {
   static bool kIsEventFdWakeupFdSupported = EventFdWakeupFd::IsSupported();
   if (kIsEventFdWakeupFdSupported) {
-    auto event_fd_wakeup_fd = std::make_unique<EventFdWakeupFd>();
+    auto event_fd_wakeup_fd =
+        std::make_unique<EventFdWakeupFd>(posix_interface);
     auto status = event_fd_wakeup_fd->Init();
     if (status.ok()) {
       return std::unique_ptr<WakeupFd>(std::move(event_fd_wakeup_fd));
@@ -114,7 +114,8 @@ absl::Status EventFdWakeupFd::Wakeup() { grpc_core::Crash("unimplemented"); }
 bool EventFdWakeupFd::IsSupported() { return false; }
 
 absl::StatusOr<std::unique_ptr<WakeupFd>>
-EventFdWakeupFd::CreateEventFdWakeupFd() {
+EventFdWakeupFd::CreateEventFdWakeupFd(
+    EventEnginePosixInterface* posix_interface) {
   return absl::NotFoundError("Eventfd wakeup fd is not supported");
 }
 

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

@@ -20,21 +20,25 @@
 
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
+#include "src/core/lib/event_engine/posix_engine/posix_interface.h"
 #include "src/core/lib/event_engine/posix_engine/wakeup_fd_posix.h"
 
 namespace grpc_event_engine::experimental {
 
 class EventFdWakeupFd : public WakeupFd {
  public:
-  EventFdWakeupFd() : WakeupFd() {}
+  explicit EventFdWakeupFd(EventEnginePosixInterface* posix_interface)
+      : WakeupFd(), posix_interface_(posix_interface) {}
   ~EventFdWakeupFd() override;
   absl::Status ConsumeWakeup() override;
   absl::Status Wakeup() override;
-  static absl::StatusOr<std::unique_ptr<WakeupFd>> CreateEventFdWakeupFd();
+  static absl::StatusOr<std::unique_ptr<WakeupFd>> CreateEventFdWakeupFd(
+      EventEnginePosixInterface* posix_interface);
   static bool IsSupported();
 
  private:
   absl::Status Init();
+  EventEnginePosixInterface* posix_interface_;
 };
 
 }  // namespace grpc_event_engine::experimental

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

@@ -18,6 +18,7 @@
 #include <utility>
 
 #include "absl/strings/str_cat.h"
+#include "src/core/lib/event_engine/posix_engine/posix_interface.h"
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/util/crash.h"  // IWYU pragma: keep
 
@@ -36,94 +37,66 @@ namespace grpc_event_engine::experimental {
 
 #ifdef GRPC_POSIX_WAKEUP_FD
 
-namespace {
-
-absl::Status SetSocketNonBlocking(int fd) {
-  int oldflags = fcntl(fd, F_GETFL, 0);
-  if (oldflags < 0) {
-    return absl::Status(absl::StatusCode::kInternal,
-                        absl::StrCat("fcntl: ", grpc_core::StrError(errno)));
-  }
-
-  oldflags |= O_NONBLOCK;
-
-  if (fcntl(fd, F_SETFL, oldflags) != 0) {
-    return absl::Status(absl::StatusCode::kInternal,
-                        absl::StrCat("fcntl: ", grpc_core::StrError(errno)));
-  }
-
-  return absl::OkStatus();
-}
-}  // namespace
-
 absl::Status PipeWakeupFd::Init() {
-  int pipefd[2];
-  int r = pipe(pipefd);
-  if (0 != r) {
-    return absl::Status(absl::StatusCode::kInternal,
-                        absl::StrCat("pipe: ", grpc_core::StrError(errno)));
-  }
-  auto status = SetSocketNonBlocking(pipefd[0]);
-  if (!status.ok()) {
-    close(pipefd[0]);
-    close(pipefd[1]);
-    return status;
-  }
-  status = SetSocketNonBlocking(pipefd[1]);
-  if (!status.ok()) {
-    close(pipefd[0]);
-    close(pipefd[1]);
-    return status;
-  }
-  SetWakeupFds(pipefd[0], pipefd[1]);
+  auto pipe_ends = posix_interface_->Pipe();
+  if (!pipe_ends.ok()) return std::move(pipe_ends).status();
+  SetWakeupFds(pipe_ends->first, pipe_ends->second);
   return absl::OkStatus();
 }
 
 absl::Status PipeWakeupFd::ConsumeWakeup() {
-  char buf[128];
-  ssize_t r;
-
+  std::array<char, 128> buf;
   for (;;) {
-    r = read(ReadFd(), buf, sizeof(buf));
-    if (r > 0) continue;
-    if (r == 0) return absl::OkStatus();
-    switch (errno) {
-      case EAGAIN:
-        return absl::OkStatus();
-      case EINTR:
-        continue;
-      default:
-        return absl::Status(absl::StatusCode::kInternal,
-                            absl::StrCat("read: ", grpc_core::StrError(errno)));
+    auto r = posix_interface_->Read(ReadFd(), absl::Span<char>(buf));
+    if (r.ok()) {
+      if (*r > 0) continue;
+      if (*r == 0) return absl::OkStatus();
+    } else if (r.IsWrongGenerationError()) {
+      return absl::Status(absl::StatusCode::kInternal,
+                          absl::StrCat("read: wrong fd generation"));
+    } else {
+      switch (*r.errno_value()) {
+        case EAGAIN:
+          return absl::OkStatus();
+        case EINTR:
+          continue;
+        default:
+          return absl::Status(
+              absl::StatusCode::kInternal,
+              absl::StrCat("read: ", grpc_core::StrError(errno)));
+      }
     }
   }
 }
 
 absl::Status PipeWakeupFd::Wakeup() {
   char c = 0;
-  while (write(WriteFd(), &c, 1) != 1 && errno == EINTR) {
+  while (posix_interface_->Write(WriteFd(), absl::Span<char>(&c, 1))
+             .IsPosixError(EINTR)) {
   }
   return absl::OkStatus();
 }
 
 PipeWakeupFd::~PipeWakeupFd() {
-  if (ReadFd() != 0) {
-    close(ReadFd());
+  if (ReadFd().ready()) {
+    posix_interface_->Close(ReadFd());
   }
-  if (WriteFd() != 0) {
-    close(WriteFd());
+  if (WriteFd().ready()) {
+    posix_interface_->Close(WriteFd());
   }
 }
 
 bool PipeWakeupFd::IsSupported() {
-  PipeWakeupFd pipe_wakeup_fd;
+  EventEnginePosixInterface posix_interface;
+  PipeWakeupFd pipe_wakeup_fd(&posix_interface);
   return pipe_wakeup_fd.Init().ok();
 }
 
-absl::StatusOr<std::unique_ptr<WakeupFd>> PipeWakeupFd::CreatePipeWakeupFd() {
+absl::StatusOr<std::unique_ptr<WakeupFd>> PipeWakeupFd::CreatePipeWakeupFd(
+    EventEnginePosixInterface* posix_interface) {
   static bool kIsPipeWakeupFdSupported = PipeWakeupFd::IsSupported();
   if (kIsPipeWakeupFdSupported) {
-    auto pipe_wakeup_fd = std::make_unique<PipeWakeupFd>();
+    auto pipe_wakeup_fd = std::make_unique<PipeWakeupFd>(posix_interface);
     auto status = pipe_wakeup_fd->Init();
     if (status.ok()) {
       return std::unique_ptr<WakeupFd>(std::move(pipe_wakeup_fd));
@@ -145,7 +118,8 @@ absl::Status PipeWakeupFd::Wakeup() { grpc_core::Crash("unimplemented"); }
 
 bool PipeWakeupFd::IsSupported() { return false; }
 
-absl::StatusOr<std::unique_ptr<WakeupFd>> PipeWakeupFd::CreatePipeWakeupFd() {
+absl::StatusOr<std::unique_ptr<WakeupFd>> PipeWakeupFd::CreatePipeWakeupFd(
+    EventEnginePosixInterface* posix_interface) {
   return absl::NotFoundError("Pipe wakeup fd is not supported");
 }
 

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

@@ -20,21 +20,25 @@
 
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
+#include "src/core/lib/event_engine/posix_engine/posix_interface.h"
 #include "src/core/lib/event_engine/posix_engine/wakeup_fd_posix.h"
 
 namespace grpc_event_engine::experimental {
 
 class PipeWakeupFd : public WakeupFd {
  public:
-  PipeWakeupFd() : WakeupFd() {}
+  explicit PipeWakeupFd(EventEnginePosixInterface* posix_interface)
+      : WakeupFd(), posix_interface_(posix_interface) {}
   ~PipeWakeupFd() override;
   absl::Status ConsumeWakeup() override;
   absl::Status Wakeup() override;
-  static absl::StatusOr<std::unique_ptr<WakeupFd>> CreatePipeWakeupFd();
+  static absl::StatusOr<std::unique_ptr<WakeupFd>> CreatePipeWakeupFd(
+      EventEnginePosixInterface* posix_interface);
   static bool IsSupported();
 
  private:
   absl::Status Init();
+  EventEnginePosixInterface* posix_interface_;
 };
 
 }  // namespace grpc_event_engine::experimental

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

@@ -45,6 +45,7 @@
 #include <grpc/support/port_platform.h>
 
 #include "absl/status/status.h"
+#include "src/core/lib/event_engine/posix_engine/posix_interface.h"
 
 namespace grpc_event_engine::experimental {
 
@@ -54,19 +55,19 @@ class WakeupFd {
   virtual absl::Status Wakeup() = 0;
   virtual ~WakeupFd() = default;
 
-  int ReadFd() { return read_fd_; }
-  int WriteFd() { return write_fd_; }
+  FileDescriptor ReadFd() { return read_fd_; }
+  FileDescriptor WriteFd() { return write_fd_; }
 
  protected:
-  WakeupFd() : read_fd_(0), write_fd_(0) {}
-  void SetWakeupFds(int read_fd, int write_fd) {
+  WakeupFd() {}
+  void SetWakeupFds(FileDescriptor read_fd, FileDescriptor write_fd) {
     read_fd_ = read_fd;
     write_fd_ = write_fd;
   }
 
  private:
-  int read_fd_;
-  int write_fd_;
+  FileDescriptor read_fd_;
+  FileDescriptor write_fd_;
 };
 
 }  // namespace grpc_event_engine::experimental

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

@@ -17,6 +17,7 @@
 
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
+#include "src/core/lib/event_engine/posix_engine/posix_interface.h"
 #include "src/core/lib/event_engine/posix_engine/wakeup_fd_eventfd.h"
 #include "src/core/lib/event_engine/posix_engine/wakeup_fd_pipe.h"
 #include "src/core/lib/event_engine/posix_engine/wakeup_fd_posix.h"
@@ -26,13 +27,16 @@ namespace grpc_event_engine::experimental {
 
 #ifdef GRPC_POSIX_WAKEUP_FD
 
-absl::StatusOr<std::unique_ptr<WakeupFd>> NotSupported() {
+absl::StatusOr<std::unique_ptr<WakeupFd>> NotSupported(
+    EventEnginePosixInterface* /* unused */) {
   return absl::NotFoundError("Wakeup-fd is not supported on this system");
 }
 
 namespace {
-absl::StatusOr<std::unique_ptr<WakeupFd>> (*g_wakeup_fd_fn)() =
-    []() -> absl::StatusOr<std::unique_ptr<WakeupFd>> (*)() {
+absl::StatusOr<std::unique_ptr<WakeupFd>> (*g_wakeup_fd_fn)(
+    EventEnginePosixInterface* posix_interface) =
+    []() -> absl::StatusOr<std::unique_ptr<WakeupFd>> (*)(
+             EventEnginePosixInterface* posix_interface) {
 #ifndef GRPC_POSIX_NO_SPECIAL_WAKEUP_FD
   if (EventFdWakeupFd::IsSupported()) {
     return &EventFdWakeupFd::CreateEventFdWakeupFd;
@@ -47,15 +51,17 @@ absl::StatusOr<std::unique_ptr<WakeupFd>> (*g_wakeup_fd_fn)() =
 
 bool SupportsWakeupFd() { return g_wakeup_fd_fn != NotSupported; }
 
-absl::StatusOr<std::unique_ptr<WakeupFd>> CreateWakeupFd() {
-  return g_wakeup_fd_fn();
+absl::StatusOr<std::unique_ptr<WakeupFd>> CreateWakeupFd(
+    EventEnginePosixInterface* posix_interface) {
+  return g_wakeup_fd_fn(posix_interface);
 }
 
 #else  // GRPC_POSIX_WAKEUP_FD
 
 bool SupportsWakeupFd() { return false; }
 
-absl::StatusOr<std::unique_ptr<WakeupFd>> CreateWakeupFd() {
+absl::StatusOr<std::unique_ptr<WakeupFd>> CreateWakeupFd(
+    EventEnginePosixInterface* /* unused */) {
   return absl::NotFoundError("Wakeup-fd is not supported on this system");
 }
 

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

@@ -19,6 +19,7 @@
 #include <memory>
 
 #include "absl/status/statusor.h"
+#include "src/core/lib/event_engine/posix_engine/posix_interface.h"
 
 namespace grpc_event_engine::experimental {
 
@@ -28,7 +29,8 @@ class WakeupFd;
 bool SupportsWakeupFd();
 
 // Create and return an initialized WakeupFd instance if supported.
-absl::StatusOr<std::unique_ptr<WakeupFd>> CreateWakeupFd();
+absl::StatusOr<std::unique_ptr<WakeupFd>> CreateWakeupFd(
+    EventEnginePosixInterface* posix_interface);
 
 }  // namespace grpc_event_engine::experimental
 

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

@@ -40,4 +40,13 @@ bool UsePollsetAlternative() {
          grpc_core::IsPollsetAlternativeEnabled();
 }
 
+// Returns true if GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER is defined.
+bool EventEngineExperimentDisabledForPython() {
+#ifdef GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER
+  return true;
+#else
+  return false;
+#endif
+}
+
 }  // namespace grpc_event_engine::experimental

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

@@ -35,6 +35,9 @@ bool UseEventEngineListener();
 // may disable the poller in some builds.
 bool UsePollsetAlternative();
 
+// Returns true if GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER is defined.
+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_pool.h

@@ -20,21 +20,25 @@
 #include <memory>
 
 #include "absl/functional/any_invocable.h"
-#include "src/core/lib/event_engine/forkable.h"
 
 namespace grpc_event_engine::experimental {
 
 // Interface for all EventEngine ThreadPool implementations
-class ThreadPool : public Forkable {
+class ThreadPool {
  public:
   // Asserts Quiesce was called.
-  ~ThreadPool() override = default;
+  virtual ~ThreadPool() = default;
   // Shut down the pool, and wait for all threads to exit.
   // This method is safe to call from within a ThreadPool thread.
   virtual void Quiesce() = 0;
   // Run must not be called after Quiesce completes
   virtual void Run(absl::AnyInvocable<void()> callback) = 0;
   virtual void Run(EventEngine::Closure* closure) = 0;
+
+#if GRPC_ENABLE_FORK_SUPPORT
+  virtual void PrepareFork() = 0;
+  virtual void PostFork() = 0;
+#endif  // GRPC_ENABLE_FORK_SUPPORT
 };
 
 // Creates a default thread pool.

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

@@ -16,30 +16,13 @@
 
 #include <memory>
 
-#include "src/core/lib/event_engine/forkable.h"
 #include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/event_engine/thread_pool/work_stealing_thread_pool.h"
-#include "src/core/util/no_destruct.h"
 
 namespace grpc_event_engine::experimental {
 
-namespace {
-grpc_core::NoDestruct<ObjectGroupForkHandler> g_thread_pool_fork_manager;
-
-class ThreadPoolForkCallbackMethods {
- public:
-  static void Prefork() { g_thread_pool_fork_manager->Prefork(); }
-  static void PostforkParent() { g_thread_pool_fork_manager->PostforkParent(); }
-  static void PostforkChild() { g_thread_pool_fork_manager->PostforkChild(); }
-};
-}  // namespace
-
 std::shared_ptr<ThreadPool> MakeThreadPool(size_t reserve_threads) {
   auto thread_pool = std::make_shared<WorkStealingThreadPool>(reserve_threads);
-  g_thread_pool_fork_manager->RegisterForkable(
-      thread_pool, ThreadPoolForkCallbackMethods::Prefork,
-      ThreadPoolForkCallbackMethods::PostforkParent,
-      ThreadPoolForkCallbackMethods::PostforkChild);
   return thread_pool;
 }
 

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

@@ -213,11 +213,13 @@ EventEngine::Closure* WorkStealingThreadPool::TheftRegistry::StealOne() {
   return nullptr;
 }
 
+#if GRPC_ENABLE_FORK_SUPPORT
+
 void WorkStealingThreadPool::PrepareFork() { pool_->PrepareFork(); }
 
-void WorkStealingThreadPool::PostforkParent() { pool_->Postfork(); }
+void WorkStealingThreadPool::PostFork() { pool_->Postfork(); }
 
-void WorkStealingThreadPool::PostforkChild() { pool_->Postfork(); }
+#endif  // GRPC_ENABLE_FORK_SUPPORT
 
 // -------- WorkStealingThreadPool::WorkStealingThreadPoolImpl --------
 

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

@@ -53,11 +53,12 @@ class WorkStealingThreadPool final : public ThreadPool {
   void Run(absl::AnyInvocable<void()> callback) override;
   void Run(EventEngine::Closure* closure) override;
 
+#if GRPC_ENABLE_FORK_SUPPORT
   // Forkable
   // These methods are exposed on the public object to allow for testing.
   void PrepareFork() override;
-  void PostforkParent() override;
-  void PostforkChild() override;
+  void PostFork() override;
+#endif  // GRPC_ENABLE_FORK_SUPPORT
 
  private:
   // A basic communication mechanism to signal waiting threads that work is

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

@@ -267,6 +267,8 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
     }
   }
 
+  bool IsCurrent() const override { return true; }
+
  private:
   enum WriteState {
     WRITE_IDLE,
@@ -809,6 +811,8 @@ class GrpcPolledFdWrapper : public GrpcPolledFd {
 
   const char* GetName() const override { return polled_fd_->GetName(); }
 
+  bool IsCurrent() const override { return true; }
+
  private:
   GrpcPolledFdWindows* polled_fd_;
 };

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

@@ -50,6 +50,10 @@ class GrpcPolledFdFactoryWindows : public GrpcPolledFdFactory {
       ares_socket_t as) override;
   void ConfigureAresChannelLocked(ares_channel channel) override;
 
+  std::unique_ptr<GrpcPolledFdFactory> NewEmptyInstance() const override {
+    return std::make_unique<GrpcPolledFdFactoryWindows>(iocp_);
+  }
+
  private:
   friend class CustomSockFuncs;
 

data/src/core/lib/event_engine/windows/windows_endpoint.h

@@ -37,12 +37,8 @@ class WindowsEndpoint : public EventEngine::Endpoint {
              SliceBuffer* data, WriteArgs args) override;
   const EventEngine::ResolvedAddress& GetPeerAddress() const override;
   const EventEngine::ResolvedAddress& GetLocalAddress() const override;
-  std::vector<size_t> AllWriteMetrics() override { return {}; }
-  std::optional<absl::string_view> GetMetricName(size_t) override {
-    return std::nullopt;
-  }
-  std::optional<size_t> GetMetricKey(absl::string_view) override {
-    return std::nullopt;
+  std::shared_ptr<TelemetryInfo> GetTelemetryInfo() const override {
+    return nullptr;
   }
 
  private:

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

@@ -44,7 +44,6 @@
 #include "src/core/lib/event_engine/windows/windows_listener.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/resource_quota/resource_quota.h"
-#include "src/core/lib/surface/init_internally.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/dump_args.h"
 #include "src/core/util/sync.h"

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

@@ -38,15 +38,13 @@
 #include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/event_engine/windows/iocp.h"
 #include "src/core/lib/event_engine/windows/windows_endpoint.h"
-#include "src/core/lib/surface/init_internally.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/time.h"
 
 namespace grpc_event_engine::experimental {
 
 class WindowsEventEngine
-    : public grpc_core::KeepsGrpcInitialized,
-      public ExtendedType<EventEngine, EventEngineWindowsSocketSupport> {
+    : public ExtendedType<EventEngine, EventEngineWindowsSocketSupport> {
  public:
   class WindowsDNSResolver : public EventEngine::DNSResolver {
    public:

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

@@ -80,15 +80,27 @@ void UnlinkIfUnixDomainSocket(
   if (un->sun_path[0] == '\0' && un->sun_path[1] != '\0') {
     return;
   }
+  // Convert UTF-8 path to Unicode.
+  std::wstring wide_path;
+  int needed = MultiByteToWideChar(CP_UTF8, 0, un->sun_path, -1, NULL, 0);
+  if (needed <= 0) {
+    return;
+  }
+  wide_path.resize(needed, L'\0');
+  if (MultiByteToWideChar(CP_UTF8, 0, un->sun_path, -1, wide_path.data(),
+                          needed) == 0) {
+    // Failed to convert UTF-8 path to wide char.
+    return;
+  }
   // For windows we need to remove the file instead of unlink.
-  DWORD attr = ::GetFileAttributesA(un->sun_path);
+  DWORD attr = ::GetFileAttributesW(wide_path.data());
   if (attr == INVALID_FILE_ATTRIBUTES) {
     return;
   }
   if (attr & FILE_ATTRIBUTE_DIRECTORY || attr & FILE_ATTRIBUTE_READONLY) {
     return;
   }
-  ::DeleteFileA(un->sun_path);
+  ::DeleteFileW(wide_path.data());
 #else
   (void)resolved_addr;
 #endif