grpc 1.52.0.pre2 → 1.53.0.pre2

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

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_LIB_EVENT_ENGINE_EXECUTOR_EXECUTOR_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_EXECUTOR_EXECUTOR_H
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXECUTOR_EXECUTOR_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXECUTOR_EXECUTOR_H
 
 #include <grpc/support/port_platform.h>
 
@@ -35,4 +35,4 @@ class Executor {
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_EXECUTOR_EXECUTOR_H
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXECUTOR_EXECUTOR_H

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

@@ -31,8 +31,10 @@ namespace experimental {
 namespace {
 grpc_core::NoDestruct<grpc_core::Mutex> g_mu;
 bool g_registered ABSL_GUARDED_BY(g_mu){false};
-grpc_core::NoDestruct<absl::flat_hash_set<Forkable*>> g_forkables
-    ABSL_GUARDED_BY(g_mu);
+
+// This must be ordered because there are ordering dependencies between
+// certain fork handlers.
+grpc_core::NoDestruct<std::vector<Forkable*>> g_forkables ABSL_GUARDED_BY(g_mu);
 }  // namespace
 
 Forkable::Forkable() { ManageForkable(this); }
@@ -48,8 +50,9 @@ void RegisterForkHandlers() {
 
 void PrepareFork() {
   grpc_core::MutexLock lock(g_mu.get());
-  for (auto* forkable : *g_forkables) {
-    forkable->PrepareFork();
+  for (auto forkable_iter = g_forkables->rbegin();
+       forkable_iter != g_forkables->rend(); ++forkable_iter) {
+    (*forkable_iter)->PrepareFork();
   }
 }
 void PostforkParent() {
@@ -68,12 +71,14 @@ void PostforkChild() {
 
 void ManageForkable(Forkable* forkable) {
   grpc_core::MutexLock lock(g_mu.get());
-  g_forkables->insert(forkable);
+  g_forkables->push_back(forkable);
 }
 
 void StopManagingForkable(Forkable* forkable) {
   grpc_core::MutexLock lock(g_mu.get());
-  g_forkables->erase(forkable);
+  auto iter = std::find(g_forkables->begin(), g_forkables->end(), forkable);
+  GPR_ASSERT(iter != g_forkables->end());
+  g_forkables->erase(iter);
 }
 
 }  // namespace experimental

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

@@ -11,8 +11,8 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-#ifndef GRPC_CORE_LIB_EVENT_ENGINE_FORKABLE_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_FORKABLE_H
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_FORKABLE_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_FORKABLE_H
 
 #include <grpc/support/port_platform.h>
 
@@ -58,4 +58,4 @@ void StopManagingForkable(Forkable* forkable);
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_FORKABLE_H
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_FORKABLE_H

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

@@ -11,8 +11,8 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-#ifndef GRPC_CORE_LIB_EVENT_ENGINE_HANDLE_CONTAINERS_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_HANDLE_CONTAINERS_H
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_HANDLE_CONTAINERS_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_HANDLE_CONTAINERS_H
 
 #include <grpc/support/port_platform.h>
 
@@ -54,6 +54,13 @@ using TaskHandleSet = absl::flat_hash_set<
     TaskHandleComparator<
         grpc_event_engine::experimental::EventEngine::TaskHandle>::Eq>;
 
+using ConnectionHandleSet = absl::flat_hash_set<
+    grpc_event_engine::experimental::EventEngine::ConnectionHandle,
+    TaskHandleComparator<
+        grpc_event_engine::experimental::EventEngine::ConnectionHandle>::Hash,
+    TaskHandleComparator<
+        grpc_event_engine::experimental::EventEngine::ConnectionHandle>::Eq>;
+
 using LookupTaskHandleSet = absl::flat_hash_set<
     grpc_event_engine::experimental::EventEngine::DNSResolver::LookupTaskHandle,
     TaskHandleComparator<grpc_event_engine::experimental::EventEngine::
@@ -64,4 +71,4 @@ using LookupTaskHandleSet = absl::flat_hash_set<
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_HANDLE_CONTAINERS_H
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_HANDLE_CONTAINERS_H

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

@@ -11,8 +11,8 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-#ifndef GRPC_CORE_LIB_EVENT_ENGINE_POLLER_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_POLLER_H
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_POLLER_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_POLLER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -59,4 +59,4 @@ class Poller {
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POLLER_H
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POLLER_H

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

@@ -0,0 +1,158 @@
+// Copyright 2022 gRPC Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_H
+
+#include <grpc/support/port_platform.h>
+
+#include <memory>
+
+#include "absl/functional/any_invocable.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+
+#include <grpc/event_engine/endpoint_config.h>
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/event_engine/memory_allocator.h>
+#include <grpc/event_engine/slice_buffer.h>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+/// This defines an interface that posix specific EventEngines endpoints
+/// may implement to support additional file descriptor related functionality.
+class PosixEndpointWithFdSupport : public EventEngine::Endpoint {
+ public:
+  /// Returns the file descriptor associated with the posix endpoint.
+  virtual int GetWrappedFd() = 0;
+
+  /// Shutdown the endpoint. This function call should trigger execution of
+  /// any pending endpoint Read/Write callbacks with appropriate error
+  /// absl::Status. After this function call any subsequent endpoint
+  /// Read/Write operations until endpoint deletion should fail with an
+  /// appropriate absl::Status.
+  ///
+  /// \a on_release_fd - If specifed, the callback is invoked when the
+  /// endpoint is destroyed/deleted. The underlying file descriptor is
+  /// released instead of being closed. The callback will get the released
+  /// file descriptor as its argument if the release operation is successful.
+  /// Otherwise it would get an appropriate error status as its argument.
+  virtual void Shutdown(absl::AnyInvocable<void(absl::StatusOr<int> release_fd)>
+                            on_release_fd) = 0;
+};
+
+/// Defines an interface that posix EventEngine listeners may implement to
+/// support additional file descriptor related functionality.
+class PosixListenerWithFdSupport : public EventEngine::Listener {
+ public:
+  /// Called when a posix listener bind operation completes. A single bind
+  /// operation may trigger creation of multiple listener fds. This callback
+  /// should be invoked once on each newly created and bound fd. If the
+  /// corresponding bind operation fails for a particular fd, this callback
+  /// must be invoked with a absl::FailedPreConditionError status.
+  ///
+  /// \a listener_fd - The listening socket fd that was bound to the specified
+  /// address.
+  using OnPosixBindNewFdCallback =
+      absl::AnyInvocable<void(absl::StatusOr<int> listener_fd)>;
+  /// Bind an address/port to this Listener.
+  ///
+  /// It is expected that multiple addresses/ports can be bound to this
+  /// Listener before Listener::Start has been called. Returns either the
+  /// bound port or an appropriate error status.
+  /// \a addr - The address to listen for incoming connections.
+  /// \a on_bind_new_fd The callback is invoked once for each newly bound
+  /// listener fd that may be created by this Bind operation.
+  virtual absl::StatusOr<int> BindWithFd(
+      const EventEngine::ResolvedAddress& addr,
+      OnPosixBindNewFdCallback on_bind_new_fd) = 0;
+
+  /// Handle an externally accepted client connection. It must return an
+  /// appropriate error status in case of failure.
+  ///
+  /// This may be invoked to process a new client connection accepted by an
+  /// external listening fd.
+  /// \a listener_fd - The external listening socket fd that accepted the new
+  /// client connection.
+  /// \a fd - The socket file descriptor representing the new client
+  /// connection.
+  /// \a pending_data - If specified, it holds any pending data that may have
+  /// already been read over the externally accepted client connection.
+  /// Otherwise, it is assumed that no data has been read over the new client
+  /// connection.
+  virtual absl::Status HandleExternalConnection(int listener_fd, int fd,
+                                                SliceBuffer* pending_data) = 0;
+
+  /// Shutdown/stop listening on all bind Fds.
+  virtual void ShutdownListeningFds() = 0;
+};
+
+/// Defines an interface that posix EventEngines may implement to
+/// support additional file descriptor related functionality.
+class PosixEventEngineWithFdSupport : public EventEngine {
+ public:
+  /// Creates a posix specific EventEngine::Endpoint from an fd which is already
+  /// assumed to be connected to a remote peer. \a fd - The connected socket
+  /// file descriptor. \a config - Additional configuration to applied to the
+  /// endpoint. \a memory_allocator - The endpoint may use the provided memory
+  /// allocator to track memory allocations.
+  virtual std::unique_ptr<PosixEndpointWithFdSupport> CreatePosixEndpointFromFd(
+      int fd, const EndpointConfig& config,
+      MemoryAllocator memory_allocator) = 0;
+
+  /// Called when the posix listener has accepted a new client connection.
+  /// \a listener_fd - The listening socket fd that accepted the new client
+  /// connection.
+  /// \a endpoint - The EventEngine endpoint to handle data exchange over the
+  /// new client connection.
+  /// \a is_external - A boolean indicating whether the new client connection
+  /// is accepted by an external listener_fd or by a listener_fd that is
+  /// managed by the EventEngine listener.
+  /// \a memory_allocator - The callback may use the provided memory
+  /// allocator to handle memory allocation operations.
+  /// \a pending_data - If specified, it holds any pending data that may have
+  /// already been read over the new client connection. Otherwise, it is
+  /// assumed that no data has been read over the new client connection.
+  using PosixAcceptCallback = absl::AnyInvocable<void(
+      int listener_fd, std::unique_ptr<EventEngine::Endpoint> endpoint,
+      bool is_external, MemoryAllocator memory_allocator,
+      SliceBuffer* pending_data)>;
+
+  /// Factory method to create a posix specific network listener / server with
+  /// fd support.
+  ///
+  /// Once a \a Listener is created and started, the \a on_accept callback will
+  /// be called once asynchronously for each established connection. This method
+  /// may return a non-OK status immediately if an error was encountered in any
+  /// synchronous steps required to create the Listener. In this case,
+  /// \a on_shutdown will never be called.
+  ///
+  /// If this method returns a Listener, then \a on_shutdown will be invoked
+  /// exactly once, when the Listener is shut down. The status passed to it will
+  /// indicate if there was a problem during shutdown.
+  ///
+  /// The provided \a MemoryAllocatorFactory is used to create \a
+  /// MemoryAllocators for Endpoint construction.
+  virtual absl::StatusOr<std::unique_ptr<PosixListenerWithFdSupport>>
+  CreatePosixListener(
+      PosixAcceptCallback on_accept,
+      absl::AnyInvocable<void(absl::Status)> on_shutdown,
+      const EndpointConfig& config,
+      std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory) = 0;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_H

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

@@ -18,6 +18,7 @@
 #include <stdint.h>
 
 #include <atomic>
+#include <initializer_list>
 #include <memory>
 
 #include "absl/status/status.h"
@@ -251,7 +252,7 @@ void ResetEventManagerOnFork() {
   while (!fork_poller_list.empty()) {
     Epoll1Poller* poller = fork_poller_list.front();
     fork_poller_list.pop_front();
-    delete poller;
+    poller->Close();
   }
   gpr_mu_unlock(&fork_fd_list_mu);
   if (grpc_core::Fork::Enabled()) {
@@ -285,7 +286,9 @@ void Epoll1EventHandle::OrphanHandle(PosixEngineClosure* on_done,
                                      int* release_fd,
                                      absl::string_view reason) {
   bool is_release_fd = (release_fd != nullptr);
+  bool was_shutdown = false;
   if (!read_closure_->IsShutdown()) {
+    was_shutdown = true;
     HandleShutdownInternal(absl::Status(absl::StatusCode::kUnknown, reason),
                            is_release_fd);
   }
@@ -293,8 +296,17 @@ void Epoll1EventHandle::OrphanHandle(PosixEngineClosure* on_done,
   // If release_fd is not NULL, we should be relinquishing control of the file
   // descriptor fd->fd (but we still own the grpc_fd structure).
   if (is_release_fd) {
+    if (!was_shutdown) {
+      epoll_event phony_event;
+      if (epoll_ctl(poller_->g_epoll_set_.epfd, EPOLL_CTL_DEL, fd_,
+                    &phony_event) != 0) {
+        gpr_log(GPR_ERROR, "OrphanHandle: epoll_ctl failed: %s",
+                grpc_core::StrError(errno).c_str());
+      }
+    }
     *release_fd = fd_;
   } else {
+    shutdown(fd_, SHUT_RDWR);
     close(fd_);
   }
 
@@ -328,13 +340,11 @@ void Epoll1EventHandle::HandleShutdownInternal(absl::Status why,
   grpc_core::StatusSetInt(&why, grpc_core::StatusIntProperty::kRpcStatus,
                           GRPC_STATUS_UNAVAILABLE);
   if (read_closure_->SetShutdown(why)) {
-    if (!releasing_fd) {
-      shutdown(fd_, SHUT_RDWR);
-    } else {
+    if (releasing_fd) {
       epoll_event phony_event;
       if (epoll_ctl(poller_->g_epoll_set_.epfd, EPOLL_CTL_DEL, fd_,
                     &phony_event) != 0) {
-        gpr_log(GPR_ERROR, "epoll_ctl failed: %s",
+        gpr_log(GPR_ERROR, "HandleShutdownInternal: epoll_ctl failed: %s",
                 grpc_core::StrError(errno).c_str());
       }
     }
@@ -344,7 +354,7 @@ void Epoll1EventHandle::HandleShutdownInternal(absl::Status why,
 }
 
 Epoll1Poller::Epoll1Poller(Scheduler* scheduler)
-    : scheduler_(scheduler), was_kicked_(false) {
+    : scheduler_(scheduler), was_kicked_(false), closed_(false) {
   g_epoll_set_.epfd = EpollCreateAndCloexec();
   wakeup_fd_ = *CreateWakeupFd();
   GPR_ASSERT(wakeup_fd_ != nullptr);
@@ -365,22 +375,26 @@ void Epoll1Poller::Shutdown() {
   delete this;
 }
 
-Epoll1Poller::~Epoll1Poller() {
+void Epoll1Poller::Close() {
+  grpc_core::MutexLock lock(&mu_);
+  if (closed_) return;
+
   if (g_epoll_set_.epfd >= 0) {
     close(g_epoll_set_.epfd);
     g_epoll_set_.epfd = -1;
   }
-  {
-    grpc_core::MutexLock lock(&mu_);
-    while (!free_epoll1_handles_list_.empty()) {
-      Epoll1EventHandle* handle = reinterpret_cast<Epoll1EventHandle*>(
-          free_epoll1_handles_list_.front());
-      free_epoll1_handles_list_.pop_front();
-      delete handle;
-    }
+
+  while (!free_epoll1_handles_list_.empty()) {
+    Epoll1EventHandle* handle =
+        reinterpret_cast<Epoll1EventHandle*>(free_epoll1_handles_list_.front());
+    free_epoll1_handles_list_.pop_front();
+    delete handle;
   }
+  closed_ = true;
 }
 
+Epoll1Poller::~Epoll1Poller() { Close(); }
+
 EventHandle* Epoll1Poller::CreateHandle(int fd, absl::string_view /*name*/,
                                         bool track_err) {
   Epoll1EventHandle* new_handle = nullptr;
@@ -546,7 +560,7 @@ Poller::WorkResult Epoll1Poller::Work(
 
 void Epoll1Poller::Kick() {
   grpc_core::MutexLock lock(&mu_);
-  if (was_kicked_) {
+  if (was_kicked_ || closed_) {
     return;
   }
   was_kicked_ = true;
@@ -561,6 +575,14 @@ Epoll1Poller* MakeEpoll1Poller(Scheduler* scheduler) {
   return nullptr;
 }
 
+void Epoll1Poller::PrepareFork() { Kick(); }
+
+// TODO(vigneshbabu): implement
+void Epoll1Poller::PostforkParent() {}
+
+// TODO(vigneshbabu): implement
+void Epoll1Poller::PostforkChild() {}
+
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
@@ -607,6 +629,12 @@ void Epoll1Poller::Kick() { grpc_core::Crash("unimplemented"); }
 // nullptr.
 Epoll1Poller* MakeEpoll1Poller(Scheduler* /*scheduler*/) { return nullptr; }
 
+void Epoll1Poller::PrepareFork() {}
+
+void Epoll1Poller::PostforkParent() {}
+
+void Epoll1Poller::PostforkChild() {}
+
 }  // namespace experimental
 }  // namespace grpc_event_engine
 

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

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EV_EPOLL1_LINUX_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EV_EPOLL1_LINUX_H
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EV_EPOLL1_LINUX_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EV_EPOLL1_LINUX_H
 #include <grpc/support/port_platform.h>
 
 #include <list>
@@ -27,6 +27,7 @@
 
 #include <grpc/event_engine/event_engine.h>
 
+#include "src/core/lib/event_engine/forkable.h"
 #include "src/core/lib/event_engine/poller.h"
 #include "src/core/lib/event_engine/posix_engine/event_poller.h"
 #include "src/core/lib/event_engine/posix_engine/internal_errqueue.h"
@@ -46,7 +47,7 @@ namespace experimental {
 class Epoll1EventHandle;
 
 // Definition of epoll1 based poller.
-class Epoll1Poller : public PosixEventPoller {
+class Epoll1Poller : public PosixEventPoller, public Forkable {
  public:
   explicit Epoll1Poller(Scheduler* scheduler);
   EventHandle* CreateHandle(int fd, absl::string_view name,
@@ -67,6 +68,13 @@ class Epoll1Poller : public PosixEventPoller {
   }
   ~Epoll1Poller() override;
 
+  // Forkable
+  void PrepareFork() override;
+  void PostforkParent() override;
+  void PostforkChild() override;
+
+  void Close();
+
  private:
   // This initial vector size may need to be tuned
   using Events = absl::InlinedVector<Epoll1EventHandle*, 5>;
@@ -79,6 +87,7 @@ class Epoll1Poller : public PosixEventPoller {
   // on file descriptors that became readable/writable.
   bool ProcessEpollEvents(int max_epoll_events_to_handle,
                           Events& pending_events);
+
   //  Do epoll_wait and store the events in g_epoll_set.events field. This does
   //  not "process" any of the events yet; that is done in ProcessEpollEvents().
   //  See ProcessEpollEvents() function for more details. It returns the number
@@ -117,6 +126,7 @@ class Epoll1Poller : public PosixEventPoller {
   bool was_kicked_ ABSL_GUARDED_BY(mu_);
   std::list<EventHandle*> free_epoll1_handles_list_ ABSL_GUARDED_BY(mu_);
   std::unique_ptr<WakeupFd> wakeup_fd_;
+  bool closed_;
 };
 
 // Return an instance of a epoll1 based poller tied to the specified event
@@ -126,4 +136,4 @@ Epoll1Poller* MakeEpoll1Poller(Scheduler* scheduler);
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EV_EPOLL1_LINUX_H
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EV_EPOLL1_LINUX_H

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

@@ -19,6 +19,7 @@
 #include <stdint.h>
 
 #include <atomic>
+#include <initializer_list>
 #include <list>
 #include <memory>
 #include <utility>
@@ -378,13 +379,13 @@ void PollEventHandle::OrphanHandle(PosixEngineClosure* on_done, int* release_fd,
       grpc_core::StatusSetInt(&shutdown_error_,
                               grpc_core::StatusIntProperty::kRpcStatus,
                               GRPC_STATUS_UNAVAILABLE);
-      // signal read/write closed to OS so that future operations fail.
-      if (!released_) {
-        shutdown(fd_, SHUT_RDWR);
-      }
       SetReadyLocked(&read_closure_);
       SetReadyLocked(&write_closure_);
     }
+    // signal read/write closed to OS so that future operations fail.
+    if (!released_) {
+      shutdown(fd_, SHUT_RDWR);
+    }
     if (!IsWatched()) {
       CloseFd();
     } else {
@@ -455,8 +456,6 @@ void PollEventHandle::ShutdownHandle(absl::Status why) {
       grpc_core::StatusSetInt(&shutdown_error_,
                               grpc_core::StatusIntProperty::kRpcStatus,
                               GRPC_STATUS_UNAVAILABLE);
-      // signal read/write closed to OS so that future operations fail.
-      shutdown(fd_, SHUT_RDWR);
       SetReadyLocked(&read_closure_);
       SetReadyLocked(&write_closure_);
     }
@@ -715,7 +714,7 @@ Poller::WorkResult PollPoller::Work(
       // well instead of crashing. This is because the poller::Work is called
       // right after an event enging is constructed. Even if phony poll is
       // expected to be used, we dont want to check for it until some actual
-      // event handles are registered. Otherwise the event engine construction
+      // event handles are registered. Otherwise the EventEngine construction
       // may crash.
       r = poll(pfds, pfd_count, timeout_ms);
     } else {

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

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EV_POLL_POSIX_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EV_POLL_POSIX_H
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EV_POLL_POSIX_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EV_POLL_POSIX_H
 
 #include <grpc/support/port_platform.h>
 
@@ -94,4 +94,4 @@ PollPoller* MakePollPoller(Scheduler* scheduler, bool use_phony_poll);
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EV_POLL_POSIX_H
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EV_POLL_POSIX_H

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

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EVENT_POLLER_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EVENT_POLLER_H
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EVENT_POLLER_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EVENT_POLLER_H
 #include <grpc/support/port_platform.h>
 
 #include <string>
@@ -108,4 +108,4 @@ class PosixEventPoller : public grpc_event_engine::experimental::Poller {
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EVENT_POLLER_H
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EVENT_POLLER_H

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

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EVENT_POLLER_POSIX_DEFAULT_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EVENT_POLLER_POSIX_DEFAULT_H
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EVENT_POLLER_POSIX_DEFAULT_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EVENT_POLLER_POSIX_DEFAULT_H
 
 #include <grpc/support/port_platform.h>
 
@@ -30,4 +30,4 @@ PosixEventPoller* MakeDefaultPoller(Scheduler* scheduler);
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EVENT_POLLER_POSIX_DEFAULT_H
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EVENT_POLLER_POSIX_DEFAULT_H

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

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_INTERNAL_ERRQUEUE_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_INTERNAL_ERRQUEUE_H
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_INTERNAL_ERRQUEUE_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_INTERNAL_ERRQUEUE_H
 
 #include <grpc/support/port_platform.h>
 
@@ -176,4 +176,4 @@ bool KernelSupportsErrqueue();
 
 #endif  // GRPC_POSIX_SOCKET_TCP
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_INTERNAL_ERRQUEUE_H
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_INTERNAL_ERRQUEUE_H

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

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_LOCKFREE_EVENT_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_LOCKFREE_EVENT_H
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_LOCKFREE_EVENT_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_LOCKFREE_EVENT_H
 #include <grpc/support/port_platform.h>
 
 #include <atomic>
@@ -70,4 +70,4 @@ class LockfreeEvent {
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_LOCKFREE_EVENT_H
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_LOCKFREE_EVENT_H