grpc 1.73.0 → 1.75.0

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

@@ -0,0 +1,263 @@
+// Copyright 2025 The 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.
+
+#include <grpc/support/port_platform.h>
+
+#ifdef GPR_APPLE
+#include <AvailabilityMacros.h>
+#ifdef AVAILABLE_MAC_OS_X_VERSION_10_12_AND_LATER
+
+#include <netinet/in.h>
+#include <sys/socket.h>
+
+#include "src/core/lib/debug/trace_flags.h"
+#include "src/core/lib/debug/trace_impl.h"
+#include "src/core/lib/event_engine/cf_engine/cfsocket_listener.h"
+#include "src/core/lib/event_engine/cf_engine/cfstream_endpoint.h"
+#include "src/core/lib/event_engine/tcp_socket_utils.h"
+#include "src/core/util/strerror.h"
+
+namespace grpc_event_engine::experimental {
+
+namespace {
+
+auto GetCfSocketResolvedAddress6(CFSocketRef ipv6cfsock) {
+  CFTypeUniqueRef<CFDataRef> sin6cfd = CFSocketCopyAddress(ipv6cfsock);
+  auto sin6 = reinterpret_cast<const sockaddr*>(CFDataGetBytePtr(sin6cfd));
+  return EventEngine::ResolvedAddress{sin6, sin6->sa_len};
+}
+
+}  // namespace
+
+CFSocketListenerImpl::CFSocketListenerImpl(
+    std::shared_ptr<CFEventEngine> engine,
+    EventEngine::Listener::AcceptCallback on_accept,
+    absl::AnyInvocable<void(absl::Status)> on_shutdown,
+    const EndpointConfig& config,
+    std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory)
+    : engine_(std::move(engine)),
+      on_accept_(std::move(on_accept)),
+      on_shutdown_(std::move(on_shutdown)),
+      memory_allocator_factory_(std::move(memory_allocator_factory)) {}
+
+CFSocketListenerImpl::~CFSocketListenerImpl() {
+  on_shutdown_(absl::OkStatus());
+  dispatch_release(queue_);
+
+  GRPC_TRACE_LOG(event_engine, INFO)
+      << "CFSocketListenerImpl::~CFSocketListenerImpl, this: " << this;
+}
+
+void CFSocketListenerImpl::Shutdown() {
+  GRPC_TRACE_LOG(event_engine, INFO)
+      << "CFSocketListenerImpl::Shutdown: this: " << this;
+
+  grpc_core::MutexLock lock(&mu_);
+
+  shutdown_ = true;
+  for (auto& [ipv6cfsock] : ipv6cfsocks_) {
+    CFSocketInvalidate(ipv6cfsock);
+  }
+  if (runloop_) {
+    CFRunLoopWakeUp(runloop_);
+    CFRunLoopStop(runloop_);
+  }
+}
+
+absl::StatusOr<int> CFSocketListenerImpl::Bind(
+    const EventEngine::ResolvedAddress& addr) {
+  grpc_core::MutexLock lock(&mu_);
+
+  if (started_) {
+    return absl::FailedPreconditionError(
+        "Listener is already started, ports can no longer be bound");
+  }
+  CHECK(addr.size() <= EventEngine::ResolvedAddress::MAX_SIZE_BYTES);
+
+  int port = ResolvedAddressGetPort(addr);
+  // if port is not specified, reuse any listening port
+  if (port == 0) {
+    for (auto& [ipv6cfsock] : ipv6cfsocks_) {
+      auto bind_addr = GetCfSocketResolvedAddress6(ipv6cfsock);
+      int bind_port = ResolvedAddressGetPort(bind_addr);
+      if (bind_port > 0) {
+        port = bind_port;
+        break;
+      }
+    }
+  }
+
+  EventEngine::ResolvedAddress addr6;
+  // treat :: or 0.0.0.0 as a family-agnostic wildcard.
+  if (MaybeGetWildcardPortFromAddress(addr).has_value()) {
+    addr6 = ResolvedAddressMakeWild6(port);
+  }
+  // convert to ipv6 if needed
+  if (!ResolvedAddressToV4Mapped(addr, &addr6)) {
+    addr6 = addr;
+  }
+  // update port
+  ResolvedAddressSetPort(addr6, port);
+
+  // open socket
+  CFSocketContext ipv6cfsock_context = {0, this, Retain, Release, nullptr};
+  auto ipv6cfsock = CFSocketCreate(kCFAllocatorDefault, PF_INET6, SOCK_STREAM,
+                                   IPPROTO_TCP, kCFSocketAcceptCallBack,
+                                   handleConnect, &ipv6cfsock_context);
+
+  // allow reuse of the address and port
+  auto sin6_fd = CFSocketGetNative(ipv6cfsock);
+  int sock_flag = 1;
+  int err = setsockopt(sin6_fd, SOL_SOCKET, SO_REUSEADDR, &sock_flag,
+                       sizeof(sock_flag));
+  if (err != 0) {
+    return absl::InternalError(absl::StrCat(
+        "CFSocketListenerImpl::Bind, setsockopt(SO_REUSEADDR) errors: ",
+        grpc_core::StrError(errno)));
+  }
+  err = setsockopt(sin6_fd, SOL_SOCKET, SO_REUSEPORT, &sock_flag,
+                   sizeof(sock_flag));
+  if (err != 0) {
+    return absl::InternalError(absl::StrCat(
+        "CFSocketListenerImpl::Bind, setsockopt(SO_REUSEPORT) errors: ",
+        grpc_core::StrError(errno)));
+  }
+
+  // bind socket to address
+  CFTypeUniqueRef<CFDataRef> sin6cfd =
+      CFDataCreate(kCFAllocatorDefault, (UInt8*)addr6.address(), addr6.size());
+  CFSocketError cf_error = CFSocketSetAddress(ipv6cfsock, sin6cfd);
+  if (cf_error != kCFSocketSuccess) {
+    return absl::InternalError(absl::StrCat(
+        "CFSocketListenerImpl::Bind, CFSocketSetAddress error: ", cf_error));
+  }
+
+  // find actual bind address and port
+  auto bind_addr = GetCfSocketResolvedAddress6(ipv6cfsock);
+  int bind_port = ResolvedAddressGetPort(bind_addr);
+
+  ipv6cfsocks_.emplace_back(ipv6cfsock);
+
+  GRPC_TRACE_LOG(event_engine, INFO)
+      << "CFSocketListenerImpl::Bind, addr: "
+      << ResolvedAddressToString(addr).value_or("")
+      << ", bind_addr: " << ResolvedAddressToString(bind_addr).value_or("")
+      << ", this: " << this;
+
+  return bind_port;
+}
+
+absl::Status CFSocketListenerImpl::Start() {
+  grpc_core::MutexLock lock(&mu_);
+
+  CHECK(!started_);
+  started_ = true;
+
+  dispatch_async_f(queue_, Ref().release(), [](void* thatPtr) {
+    grpc_core::RefCountedPtr<CFSocketListenerImpl> that{
+        static_cast<CFSocketListenerImpl*>(thatPtr)};
+
+    GRPC_TRACE_LOG(event_engine, INFO)
+        << "CFSocketListenerImpl::Start, running CFRunLoop"
+        << ", this: " << thatPtr;
+
+    {
+      grpc_core::MutexLock lock(&that->mu_);
+      if (that->shutdown_) {
+        return;
+      }
+
+      that->runloop_ = CFRunLoopGetCurrent();
+      for (auto& [ipv6cfsock] : that->ipv6cfsocks_) {
+        CFTypeUniqueRef<CFRunLoopSourceRef> ipv6cfsock_source =
+            CFSocketCreateRunLoopSource(kCFAllocatorDefault, ipv6cfsock, 0);
+        CFRunLoopAddSource(CFRunLoopGetCurrent(), ipv6cfsock_source,
+                           kCFRunLoopDefaultMode);
+      }
+    }
+
+    CFRunLoopRun();
+
+    GRPC_TRACE_LOG(event_engine, INFO)
+        << "CFSocketListenerImpl::Start, CFRunLoop stopped"
+        << ", this: " << thatPtr;
+  });
+
+  return absl::OkStatus();
+}
+
+/* static */
+void CFSocketListenerImpl::handleConnect(CFSocketRef s,
+                                         CFSocketCallBackType type,
+                                         CFDataRef address, const void* data,
+                                         void* info) {
+  CFSocketListenerImpl* self = static_cast<CFSocketListenerImpl*>(info);
+
+  switch (type) {
+    case kCFSocketAcceptCallBack: {
+      std::string peer_name = "unknown";
+      auto peer_sin6 =
+          reinterpret_cast<const sockaddr*>(CFDataGetBytePtr(address));
+      auto peer_addr =
+          EventEngine::ResolvedAddress(peer_sin6, peer_sin6->sa_len);
+      auto addr_uri = ResolvedAddressToURI(peer_addr);
+      if (!addr_uri.ok()) {
+        GRPC_TRACE_LOG(event_engine, ERROR)
+            << "invalid peer name: " << addr_uri.status() << ", this: " << self;
+      } else {
+        peer_name = *addr_uri;
+      }
+
+      auto socketHandle = *static_cast<const CFSocketNativeHandle*>(data);
+      auto endpoint = std::make_unique<CFStreamEndpoint>(
+          self->engine_,
+          self->memory_allocator_factory_->CreateMemoryAllocator(
+              absl::StrCat("endpoint-tcp-server-connection: ", peer_name)));
+
+      endpoint->AcceptSocket(
+          [that = self->Ref(), socketHandle, peer_name = std::move(peer_name),
+           endpoint = std::move(endpoint)](absl::Status status) mutable {
+            if (!status.ok()) {
+              GRPC_TRACE_LOG(event_engine, ERROR)
+                  << "CFSocketListenerImpl::handleConnect, accept failed: "
+                  << status << ", this: " << that.get();
+              return;
+            }
+
+            that->on_accept_(
+                std::move(endpoint),
+                that->memory_allocator_factory_->CreateMemoryAllocator(
+                    absl::StrCat("on-accept-tcp-server-connection: ",
+                                 peer_name)));
+            GRPC_TRACE_LOG(event_engine, INFO)
+                << "CFSocketListenerImpl::handleConnect, accepted socket: "
+                << socketHandle << ", peer_name: " << peer_name
+                << ", this: " << that.get();
+          },
+          socketHandle, peer_addr);
+
+      break;
+    }
+    default:
+      GRPC_TRACE_LOG(event_engine, ERROR)
+          << "CFSocketListenerImpl::handleConnect, unexpected type: " << type
+          << ", this: " << self;
+      break;
+  }
+}
+
+}  // namespace grpc_event_engine::experimental
+
+#endif  // AVAILABLE_MAC_OS_X_VERSION_10_12_AND_LATER
+#endif  // GPR_APPLE

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

@@ -0,0 +1,107 @@
+// Copyright 2025 The 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_CF_ENGINE_CFSOCKET_LISTENER_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_CF_ENGINE_CFSOCKET_LISTENER_H
+#include <grpc/support/port_platform.h>
+
+#ifdef GPR_APPLE
+#include <AvailabilityMacros.h>
+#ifdef AVAILABLE_MAC_OS_X_VERSION_10_12_AND_LATER
+
+#include <CoreFoundation/CoreFoundation.h>
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/event_engine/cf_engine/cf_engine.h"
+#include "src/core/lib/event_engine/cf_engine/cftype_unique_ref.h"
+#include "src/core/util/ref_counted.h"
+#include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/sync.h"
+
+namespace grpc_event_engine::experimental {
+
+class CFSocketListenerImpl
+    : public grpc_core::RefCounted<CFSocketListenerImpl> {
+ public:
+  CFSocketListenerImpl(
+      std::shared_ptr<CFEventEngine> engine,
+      EventEngine::Listener::AcceptCallback on_accept,
+      absl::AnyInvocable<void(absl::Status)> on_shutdown,
+      const EndpointConfig& config,
+      std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory);
+  ~CFSocketListenerImpl();
+
+  absl::StatusOr<int> Bind(const EventEngine::ResolvedAddress& addr);
+  absl::Status Start();
+
+  void Shutdown();
+
+ private:
+  static const void* Retain(const void* info) {
+    auto that = static_cast<const CFSocketListenerImpl*>(info);
+    return that->Ref().release();
+  }
+
+  static void Release(const void* info) {
+    auto that = static_cast<const CFSocketListenerImpl*>(info);
+    that->Unref();
+  }
+
+  static void handleConnect(CFSocketRef s, CFSocketCallBackType type,
+                            CFDataRef address, const void* data, void* info);
+
+ private:
+  std::shared_ptr<CFEventEngine> engine_;
+  dispatch_queue_t queue_ = dispatch_queue_create("cfsocket_listener", nullptr);
+
+  grpc_core::Mutex mu_;
+  bool started_ ABSL_GUARDED_BY(mu_) = false;
+  bool shutdown_ ABSL_GUARDED_BY(mu_) = false;
+  std::vector<std::tuple<CFTypeUniqueRef<CFSocketRef>>> ipv6cfsocks_
+      ABSL_GUARDED_BY(mu_);
+  CFRunLoopRef runloop_ ABSL_GUARDED_BY(mu_);
+
+  EventEngine::Listener::AcceptCallback on_accept_;
+  absl::AnyInvocable<void(absl::Status)> on_shutdown_;
+  std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory_;
+};
+
+class CFSocketListener : public EventEngine::Listener {
+ public:
+  CFSocketListener(
+      std::shared_ptr<CFEventEngine> engine, Listener::AcceptCallback on_accept,
+      absl::AnyInvocable<void(absl::Status)> on_shutdown,
+      const EndpointConfig& config,
+      std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory)
+      : impl_(grpc_core::MakeRefCounted<CFSocketListenerImpl>(
+            std::move(engine), std::move(on_accept), std::move(on_shutdown),
+            config, std::move(memory_allocator_factory))) {}
+
+  ~CFSocketListener() override { impl_->Shutdown(); }
+
+  absl::StatusOr<int> Bind(const EventEngine::ResolvedAddress& addr) override {
+    return impl_->Bind(addr);
+  };
+
+  absl::Status Start() override { return impl_->Start(); };
+
+ private:
+  grpc_core::RefCountedPtr<CFSocketListenerImpl> impl_;
+};
+
+}  // namespace grpc_event_engine::experimental
+
+#endif  // AVAILABLE_MAC_OS_X_VERSION_10_12_AND_LATER
+#endif  // GPR_APPLE
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_CF_ENGINE_CFSOCKET_LISTENER_H

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

@@ -72,6 +72,26 @@ bool CFStreamEndpointImpl::CancelConnect(absl::Status status) {
   return open_event_.SetShutdown(std::move(status));
 }
 
+void CFStreamEndpointImpl::AcceptSocket(
+    absl::AnyInvocable<void(absl::Status)> on_connect,
+    CFSocketNativeHandle sock, const EventEngine::ResolvedAddress& addr) {
+  peer_address_ = addr;
+  auto host_port = ResolvedAddressToNormalizedString(peer_address_);
+  if (!host_port.ok()) {
+    on_connect(std::move(host_port).status());
+    return;
+  }
+
+  peer_address_string_ = host_port.value();
+  GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+      << "CFStreamEndpointImpl::AcceptSocket, host_port: "
+      << peer_address_string_;
+
+  CFStreamCreatePairWithSocket(nullptr, sock, &cf_read_stream_,
+                               &cf_write_stream_);
+  SetupStreams(std::move(on_connect));
+}
+
 void CFStreamEndpointImpl::Connect(
     absl::AnyInvocable<void(absl::Status)> on_connect,
     EventEngine::ResolvedAddress addr) {
@@ -105,6 +125,11 @@ void CFStreamEndpointImpl::Connect(
   CFStreamCreatePairWithSocketToHost(NULL, host, port, &cf_read_stream_,
                                      &cf_write_stream_);
 
+  SetupStreams(std::move(on_connect));
+}
+
+void CFStreamEndpointImpl::SetupStreams(
+    absl::AnyInvocable<void(absl::Status)> on_connect) {
   CFStreamClientContext cf_context = {0, this, Retain, Release, nullptr};
   CFReadStreamSetClient(
       cf_read_stream_,
@@ -223,9 +248,9 @@ CFStreamEndpointImpl::CFStreamEndpointImpl(
     std::shared_ptr<CFEventEngine> engine, MemoryAllocator memory_allocator)
     : engine_(std::move(engine)),
       memory_allocator_(std::move(memory_allocator)),
-      open_event_(engine_.get()),
-      read_event_(engine_.get()),
-      write_event_(engine_.get()) {
+      open_event_(engine_->thread_pool()),
+      read_event_(engine_->thread_pool()),
+      write_event_(engine_->thread_pool()) {
   open_event_.InitEvent();
   read_event_.InitEvent();
   write_event_.InitEvent();
@@ -235,6 +260,9 @@ CFStreamEndpointImpl::~CFStreamEndpointImpl() {
   open_event_.DestroyEvent();
   read_event_.DestroyEvent();
   write_event_.DestroyEvent();
+
+  GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+      << "CFStreamEndpointImpl::~CFStreamEndpointImpl: this: " << this;
 }
 
 void CFStreamEndpointImpl::Shutdown() {

data/src/core/lib/event_engine/cf_engine/cfstream_endpoint.h

@@ -60,7 +60,13 @@ class CFStreamEndpointImpl
                EventEngine::ResolvedAddress addr);
   bool CancelConnect(absl::Status status);
 
+  void AcceptSocket(absl::AnyInvocable<void(absl::Status)> on_connect,
+                    CFSocketNativeHandle sock,
+                    const EventEngine::ResolvedAddress& addr);
+
  private:
+  void SetupStreams(absl::AnyInvocable<void(absl::Status)> on_connect);
+
   void DoWrite(absl::AnyInvocable<void(absl::Status)> on_writable,
                SliceBuffer* data);
   void DoRead(absl::AnyInvocable<void(absl::Status)> on_read,
@@ -124,12 +130,8 @@ class CFStreamEndpoint : public EventEngine::Endpoint {
     return impl_->GetLocalAddress();
   }
 
-  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;
   }
 
  public:
@@ -141,6 +143,12 @@ class CFStreamEndpoint : public EventEngine::Endpoint {
     return impl_->CancelConnect(std::move(status));
   }
 
+  void AcceptSocket(absl::AnyInvocable<void(absl::Status)> on_connect,
+                    CFSocketNativeHandle sock,
+                    const EventEngine::ResolvedAddress& addr) {
+    return impl_->AcceptSocket(std::move(on_connect), sock, addr);
+  }
+
  private:
   grpc_core::RefCountedPtr<CFStreamEndpointImpl> impl_;
 };

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

@@ -0,0 +1,40 @@
+// Copyright 2025 The 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.
+
+#include "src/core/lib/event_engine/endpoint_channel_arg_wrapper.h"
+
+#include "src/core/util/useful.h"
+namespace grpc_event_engine {
+namespace experimental {
+
+EndpointChannelArgWrapper::EndpointChannelArgWrapper(
+    std::unique_ptr<EventEngine::Endpoint> endpoint)
+    : endpoint_(std::move(endpoint)) {}
+
+std::unique_ptr<EventEngine::Endpoint>
+EndpointChannelArgWrapper::TakeEndpoint() {
+  return std::move(endpoint_);
+}
+
+absl::string_view EndpointChannelArgWrapper::ChannelArgName() {
+  return "grpc.internal.subchannel_endpoint";
+}
+
+int EndpointChannelArgWrapper::ChannelArgsCompare(
+    const EndpointChannelArgWrapper* a, const EndpointChannelArgWrapper* b) {
+  return QsortCompare(a, b);
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine

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

@@ -0,0 +1,60 @@
+// Copyright 2025 The 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_ENDPOINT_CHANNEL_ARG_WRAPPER_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_ENDPOINT_CHANNEL_ARG_WRAPPER_H
+
+#include <grpc/event_engine/event_engine.h>
+
+#include <memory>
+
+#include "src/core/util/ref_counted.h"
+
+namespace grpc_event_engine {
+
+namespace experimental {
+
+/// Wrapper for EventEngine::Endpoint to enable storing it in channel args.
+///
+/// This class encapsulates a `std::unique_ptr<EventEngine::Endpoint>` so that
+/// an already-connected endpoint can be passed through channel arguments.
+/// This is useful when creating a channel with a pre-established connection,
+/// such as when using `CreateChannelFromEndpoint()` or `CreateChannelFromFd()`.
+///
+/// The wrapper provides:
+/// - Ownership management via unique_ptr
+/// - A static `ChannelArgName()` method to identify the channel arg
+/// - A comparison function for use in channel args internals
+///
+/// Note: This is intended for internal use only.
+class EndpointChannelArgWrapper
+    : public grpc_core::RefCounted<EndpointChannelArgWrapper> {
+ public:
+  explicit EndpointChannelArgWrapper(
+      std::unique_ptr<EventEngine::Endpoint> endpoint);
+
+  std::unique_ptr<EventEngine::Endpoint> TakeEndpoint();
+
+  static absl::string_view ChannelArgName();
+  static int ChannelArgsCompare(const EndpointChannelArgWrapper* a,
+                                const EndpointChannelArgWrapper* b);
+
+ private:
+  std::unique_ptr<EventEngine::Endpoint> endpoint_;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_ENDPOINT_CHANNEL_ARG_WRAPPER_H

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

@@ -15,9 +15,16 @@
 #include <grpc/support/port_platform.h>
 
 #include "absl/strings/str_cat.h"
+#include "src/core/telemetry/context_list_entry.h"
 
 namespace grpc_event_engine::experimental {
 
+EventEngine::Endpoint::WriteArgs::~WriteArgs() {
+  if (google_specific_ != nullptr) {
+    delete reinterpret_cast<grpc_core::ContextList*>(google_specific_);
+  }
+}
+
 const EventEngine::TaskHandle EventEngine::TaskHandle::kInvalid = {-1, -1};
 const EventEngine::ConnectionHandle EventEngine::ConnectionHandle::kInvalid = {
     -1, -1};

data/src/core/lib/event_engine/extensions/channelz.h

@@ -34,19 +34,23 @@ class ChannelzExtension {
 
   void SetSocketNode(
       grpc_core::RefCountedPtr<grpc_core::channelz::SocketNode> socket_node) {
-    data_source_ =
-        std::make_unique<EndpointDataSource>(std::move(socket_node), this);
+    data_source_.emplace(std::move(socket_node), this);
   }
 
+ protected:
+  void ShutdownChannelzExtension() { data_source_.reset(); }
+
  private:
   class EndpointDataSource final : public grpc_core::channelz::DataSource {
    public:
     EndpointDataSource(
         grpc_core::RefCountedPtr<grpc_core::channelz::SocketNode> socket_node,
         ChannelzExtension* ep)
-        : grpc_core::channelz::DataSource(std::move(socket_node)), ep_(ep) {}
-    ~EndpointDataSource() { ResetDataSource(); }
-    void AddData(grpc_core::channelz::DataSink& sink) override {
+        : grpc_core::channelz::DataSource(std::move(socket_node)), ep_(ep) {
+      SourceConstructed();
+    }
+    ~EndpointDataSource() { SourceDestructing(); }
+    void AddData(grpc_core::channelz::DataSink sink) override {
       ep_->AddJson(sink);
     }
 
@@ -54,7 +58,7 @@ class ChannelzExtension {
     ChannelzExtension* ep_;
   };
 
-  std::unique_ptr<EndpointDataSource> data_source_;
+  std::optional<EndpointDataSource> data_source_;
 };
 
 }  // namespace grpc_event_engine::experimental

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

@@ -62,6 +62,9 @@ class GrpcPolledFd {
   virtual ares_socket_t GetWrappedAresSocketLocked() = 0;
   // A unique name, for logging
   virtual const char* GetName() const = 0;
+  // Return if the FD is "current" - particularly, if it is of the same fork
+  // generation in case of Posix
+  virtual bool IsCurrent() const = 0;
 };
 
 // A GrpcPolledFdFactory is 1-to-1 with and owned by a GrpcAresRequest. It knows
@@ -80,6 +83,8 @@ class GrpcPolledFdFactory {
       ares_socket_t as) = 0;
   // Optionally configures the ares channel after creation
   virtual void ConfigureAresChannelLocked(ares_channel channel) = 0;
+  // Creates a new instance of the same class. This is used during the fork.
+  virtual std::unique_ptr<GrpcPolledFdFactory> NewEmptyInstance() const = 0;
 };
 
 }  // namespace grpc_event_engine::experimental