grpc 1.73.0 → 1.74.0

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

@@ -15,6 +15,7 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <cstddef>
 #include <string>
 #include <vector>
 
@@ -53,13 +54,14 @@
 #include <utility>
 
 #include "absl/functional/any_invocable.h"
-#include "absl/hash/hash.h"
 #include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/strings/match.h"
 #include "absl/strings/numbers.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
+#include "absl/strings/string_view.h"
+#include "absl/strings/substitute.h"
 #include "src/core/config/config_vars.h"
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
@@ -67,7 +69,6 @@
 #include "src/core/lib/event_engine/grpc_polled_fd.h"
 #include "src/core/lib/event_engine/time_util.h"
 #include "src/core/lib/iomgr/resolved_address.h"
-#include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/util/debug_location.h"
 #include "src/core/util/host_port.h"
 #include "src/core/util/orphanable.h"
@@ -107,9 +108,9 @@ absl::Status AresStatusToAbslStatus(int status, absl::string_view error_msg) {
 constexpr EventEngine::Duration kAresBackupPollAlarmDuration =
     std::chrono::seconds(1);
 
-bool IsIpv6LoopbackAvailable() {
+bool AresIsIpv6LoopbackAvailable() {
 #ifdef GRPC_POSIX_SOCKET_ARES_EV_DRIVER
-  return PosixSocketWrapper::IsIpv6LoopbackAvailable();
+  return IsIpv6LoopbackAvailable();
 #elif defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
   // TODO(yijiem): implement this for Windows
   return true;
@@ -189,73 +190,118 @@ struct HostnameQueryArg : public QueryArg {
   std::vector<EventEngine::ResolvedAddress> result;
 };
 
-}  // namespace
-
-absl::StatusOr<grpc_core::OrphanablePtr<AresResolver>>
-AresResolver::CreateAresResolver(
-    absl::string_view dns_server,
-    std::unique_ptr<GrpcPolledFdFactory> polled_fd_factory,
-    std::shared_ptr<EventEngine> event_engine) {
+absl::Status InitAresChannel(absl::string_view dns_server,
+                             GrpcPolledFdFactory& polled_fd_factory,
+                             ares_channel* channel) {
   ares_options opts = {};
   opts.flags |= ARES_FLAG_STAYOPEN;
   if (g_event_engine_grpc_ares_test_only_force_tcp) {
     opts.flags |= ARES_FLAG_USEVC;
   }
-  ares_channel channel;
-  int status = ares_init_options(&channel, &opts, ARES_OPT_FLAGS);
+  int status = ares_init_options(channel, &opts, ARES_OPT_FLAGS);
   if (status != ARES_SUCCESS) {
     LOG(ERROR) << "ares_init_options failed, status: " << status;
     return AresStatusToAbslStatus(
         status,
         absl::StrCat("Failed to init c-ares channel: ", ares_strerror(status)));
   }
-  event_engine_grpc_ares_test_only_inject_config(&channel);
-  polled_fd_factory->ConfigureAresChannelLocked(channel);
+  event_engine_grpc_ares_test_only_inject_config(channel);
+  polled_fd_factory.ConfigureAresChannelLocked(*channel);
   if (!dns_server.empty()) {
-    absl::Status status = SetRequestDNSServer(dns_server, &channel);
+    absl::Status status = SetRequestDNSServer(dns_server, channel);
     if (!status.ok()) {
       return status;
     }
   }
-  return grpc_core::MakeOrphanable<AresResolver>(
-      std::move(polled_fd_factory), std::move(event_engine), channel);
+  return absl::OkStatus();
+}
+
+}  // namespace
+
+// AresResolver::ReinitHandle
+#ifdef GRPC_ENABLE_FORK_SUPPORT
+
+AresResolver::ReinitHandle::ReinitHandle(AresResolver* resolver)
+    : resolver_(resolver) {}
+
+void AresResolver::ReinitHandle::OnResolverGone() {
+  grpc_core::MutexLock lock(&mutex_);
+  resolver_ = nullptr;
+}
+
+void AresResolver::ReinitHandle::Reset(const absl::Status& status) {
+  grpc_core::MutexLock lock(&mutex_);
+  if (resolver_ != nullptr) {
+    resolver_->Reset(status);
+  }
+}
+
+void AresResolver::ReinitHandle::Restart() {
+  grpc_core::MutexLock lock(&mutex_);
+  if (resolver_ != nullptr) {
+    resolver_->Restart();
+  }
+}
+
+#endif  // GRPC_ENABLE_FORK_SUPPORT
+
+// AresResolver
+
+absl::StatusOr<grpc_core::OrphanablePtr<AresResolver>>
+AresResolver::CreateAresResolver(
+    absl::string_view dns_server,
+    std::unique_ptr<GrpcPolledFdFactory> polled_fd_factory,
+    std::shared_ptr<EventEngine> event_engine) {
+  ares_channel channel;
+  absl::Status status =
+      InitAresChannel(dns_server, *polled_fd_factory, &channel);
+  if (!status.ok()) {
+    return status;
+  }
+  return grpc_core::MakeOrphanable<AresResolver>(std::move(polled_fd_factory),
+                                                 std::move(event_engine),
+                                                 channel, dns_server);
 }
 
 AresResolver::AresResolver(
     std::unique_ptr<GrpcPolledFdFactory> polled_fd_factory,
-    std::shared_ptr<EventEngine> event_engine, ares_channel channel)
+    std::shared_ptr<EventEngine> event_engine, ares_channel channel,
+    absl::string_view dns_server)
     : RefCountedDNSResolverInterface(
           GRPC_TRACE_FLAG_ENABLED(cares_resolver) ? "AresResolver" : nullptr),
       channel_(channel),
       polled_fd_factory_(std::move(polled_fd_factory)),
+#ifdef GRPC_ENABLE_FORK_SUPPORT
+      dns_server_(dns_server),
+#endif  // GRPC_ENABLE_FORK_SUPPORT
       event_engine_(std::move(event_engine)) {
+  (void)dns_server;  // Used whether or not compiled with fork support
   polled_fd_factory_->Initialize(&mutex_, event_engine_.get());
 }
 
 AresResolver::~AresResolver() {
   CHECK(fd_node_list_.empty());
   CHECK(callback_map_.empty());
+  CHECK_NE(channel_, nullptr);
   ares_destroy(channel_);
 }
 
 void AresResolver::Orphan() {
+#ifdef GRPC_ENABLE_FORK_SUPPORT
+  // Do this before locking &mutex_ - ensures there will be no deadlock if
+  // resolver is being orphaned during fork.
+  {
+    grpc_core::MutexLock handle_lock(&reinit_handle_mu_);
+    if (reinit_handle_ != nullptr) {
+      reinit_handle_->OnResolverGone();
+    }
+  }
+#endif
   {
     grpc_core::MutexLock lock(&mutex_);
     shutting_down_ = true;
-    if (ares_backup_poll_alarm_handle_.has_value()) {
-      event_engine_->Cancel(*ares_backup_poll_alarm_handle_);
-      ares_backup_poll_alarm_handle_.reset();
-    }
-    for (const auto& fd_node : fd_node_list_) {
-      if (!fd_node->already_shutdown) {
-        GRPC_TRACE_LOG(cares_resolver, INFO)
-            << "(EventEngine c-ares resolver) resolver: " << this
-            << " shutdown fd: " << fd_node->polled_fd->GetName();
-        CHECK(fd_node->polled_fd->ShutdownLocked(
-            absl::CancelledError("AresResolver::Orphan")));
-        fd_node->already_shutdown = true;
-      }
-    }
+    ShutdownLocked(absl::CancelledError("AresResolver::Orphan"),
+                   "resolver orphaned");
   }
   Unref(DEBUG_LOCATION, "Orphan");
 }
@@ -321,7 +367,8 @@ void AresResolver::LookupHostname(
   grpc_core::MutexLock lock(&mutex_);
   callback_map_.emplace(++id_, std::move(callback));
   auto* resolver_arg = new HostnameQueryArg(this, id_, name, port);
-  if (IsIpv6LoopbackAvailable()) {
+  CHECK_NE(channel_, nullptr);
+  if (AresIsIpv6LoopbackAvailable()) {
     // Note that using AF_UNSPEC for both IPv6 and IPv4 queries does not work in
     // all cases, e.g. for localhost:<> it only gets back the IPv6 result (i.e.
     // ::1).
@@ -368,6 +415,7 @@ void AresResolver::LookupSRV(
   grpc_core::MutexLock lock(&mutex_);
   callback_map_.emplace(++id_, std::move(callback));
   auto* resolver_arg = new QueryArg(this, id_, host);
+  CHECK_NE(channel_, nullptr);
   ares_query(channel_, std::string(host).c_str(), ns_c_in, ns_t_srv,
              &AresResolver::OnSRVQueryDoneLocked, resolver_arg);
   CheckSocketsLocked();
@@ -403,6 +451,7 @@ void AresResolver::LookupTXT(
   grpc_core::MutexLock lock(&mutex_);
   callback_map_.emplace(++id_, std::move(callback));
   auto* resolver_arg = new QueryArg(this, id_, host);
+  CHECK_NE(channel_, nullptr);
   ares_search(channel_, std::string(host).c_str(), ns_c_in, ns_t_txt,
               &AresResolver::OnTXTDoneLocked, resolver_arg);
   CheckSocketsLocked();
@@ -411,15 +460,17 @@ void AresResolver::LookupTXT(
 
 void AresResolver::CheckSocketsLocked() {
   FdNodeList new_list;
-  if (!shutting_down_) {
+  if (!shutting_down_ && channel_ != nullptr) {
     ares_socket_t socks[ARES_GETSOCK_MAXNUM] = {};
     int socks_bitmask = ares_getsock(channel_, socks, ARES_GETSOCK_MAXNUM);
     for (size_t i = 0; i < ARES_GETSOCK_MAXNUM; i++) {
       if (ARES_GETSOCK_READABLE(socks_bitmask, i) ||
           ARES_GETSOCK_WRITABLE(socks_bitmask, i)) {
-        auto iter = std::find_if(
-            fd_node_list_.begin(), fd_node_list_.end(),
-            [sock = socks[i]](const auto& node) { return node->as == sock; });
+        auto iter = std::find_if(fd_node_list_.begin(), fd_node_list_.end(),
+                                 [sock = socks[i]](const auto& node) {
+                                   return node->as == sock &&
+                                          node->polled_fd->IsCurrent();
+                                 });
         if (iter == fd_node_list_.end()) {
           GRPC_TRACE_LOG(cares_resolver, INFO)
               << "(EventEngine c-ares resolver) resolver:" << this
@@ -530,14 +581,16 @@ void AresResolver::OnReadable(FdNode* fd_node, absl::Status status) {
   GRPC_TRACE_LOG(cares_resolver, INFO)
       << "(EventEngine c-ares resolver) OnReadable: fd: " << fd_node->as
       << "; request: " << this << "; status: " << status;
-  if (status.ok() && !shutting_down_) {
+  if (status.ok() && !shutting_down_ && channel_ != nullptr) {
     ares_process_fd(channel_, fd_node->as, ARES_SOCKET_BAD);
-  } else {
+  } else if (fd_node->polled_fd->IsCurrent() && channel_ != nullptr) {
     // If error is not absl::OkStatus() or the resolution was cancelled, it
     // means the fd has been shutdown or timed out. The pending lookups made
     // on this request will be cancelled by the following ares_cancel(). The
     // remaining file descriptors in this request will be cleaned up in the
     // following Work() method.
+    //
+    // Nothing is done if the handle is not current.
     ares_cancel(channel_);
   }
   CheckSocketsLocked();
@@ -550,9 +603,9 @@ void AresResolver::OnWritable(FdNode* fd_node, absl::Status status) {
   GRPC_TRACE_LOG(cares_resolver, INFO)
       << "(EventEngine c-ares resolver) OnWritable: fd: " << fd_node->as
       << "; request:" << this << "; status: " << status;
-  if (status.ok() && !shutting_down_) {
+  if (status.ok() && !shutting_down_ && channel_ != nullptr) {
     ares_process_fd(channel_, ARES_SOCKET_BAD, fd_node->as);
-  } else {
+  } else if (fd_node->polled_fd->IsCurrent() && channel_ != nullptr) {
     // If error is not absl::OkStatus() or the resolution was cancelled, it
     // means the fd has been shutdown or timed out. The pending lookups made
     // on this request will be cancelled by the following ares_cancel(). The
@@ -577,7 +630,7 @@ void AresResolver::OnAresBackupPollAlarm() {
   GRPC_TRACE_LOG(cares_resolver, INFO)
       << "(EventEngine c-ares resolver) request:" << this
       << " OnAresBackupPollAlarm shutting_down=" << shutting_down_;
-  if (!shutting_down_) {
+  if (!shutting_down_ && channel_ != nullptr) {
     for (const auto& fd_node : fd_node_list_) {
       if (!fd_node->already_shutdown) {
         GRPC_TRACE_LOG(cares_resolver, INFO)
@@ -665,7 +718,10 @@ void AresResolver::OnHostbynameDoneLocked(void* arg, int status,
   if (hostname_qa->pending_requests == 0) {
     auto nh =
         ares_resolver->callback_map_.extract(hostname_qa->callback_map_id);
-    CHECK(!nh.empty());
+    if (nh.empty()) {
+      delete hostname_qa;
+      return;
+    }
     CHECK(std::holds_alternative<
           EventEngine::DNSResolver::LookupHostnameCallback>(nh.mapped()));
     auto callback = std::get<EventEngine::DNSResolver::LookupHostnameCallback>(
@@ -692,7 +748,9 @@ void AresResolver::OnSRVQueryDoneLocked(void* arg, int status, int /*timeouts*/,
   std::unique_ptr<QueryArg> qa(static_cast<QueryArg*>(arg));
   auto* ares_resolver = qa->ares_resolver;
   auto nh = ares_resolver->callback_map_.extract(qa->callback_map_id);
-  CHECK(!nh.empty());
+  if (nh.empty()) {
+    return;
+  }
   CHECK(std::holds_alternative<EventEngine::DNSResolver::LookupSRVCallback>(
       nh.mapped()));
   auto callback = std::get<EventEngine::DNSResolver::LookupSRVCallback>(
@@ -753,7 +811,9 @@ void AresResolver::OnTXTDoneLocked(void* arg, int status, int /*timeouts*/,
   std::unique_ptr<QueryArg> qa(static_cast<QueryArg*>(arg));
   auto* ares_resolver = qa->ares_resolver;
   auto nh = ares_resolver->callback_map_.extract(qa->callback_map_id);
-  CHECK(!nh.empty());
+  if (nh.empty()) {
+    return;
+  }
   CHECK(std::holds_alternative<EventEngine::DNSResolver::LookupTXTCallback>(
       nh.mapped()));
   auto callback = std::get<EventEngine::DNSResolver::LookupTXTCallback>(
@@ -809,6 +869,65 @@ void AresResolver::OnTXTDoneLocked(void* arg, int status, int /*timeouts*/,
       });
 }
 
+#ifdef GRPC_ENABLE_FORK_SUPPORT
+
+std::weak_ptr<AresResolver::ReinitHandle> AresResolver::GetReinitHandle() {
+  grpc_core::MutexLock lock(&reinit_handle_mu_);
+  if (reinit_handle_ == nullptr) {
+    reinit_handle_ = ReinitHandle::New(this);
+  }
+  return reinit_handle_;
+}
+
+void AresResolver::Reset(const absl::Status& reason) {
+  auto self = RefIfNonZero();
+  if (self == nullptr) {
+    return;
+  }
+  grpc_core::MutexLock lock(&mutex_);
+  for (auto& [_, callback] : callback_map_) {
+    event_engine_->Run(
+        [callback = std::move(callback), reason = reason]() mutable {
+          std::visit([&](auto& cb) { cb(reason); }, callback);
+        });
+  }
+  callback_map_.clear();
+  ShutdownLocked(reason, "resolver reset");
+  CheckSocketsLocked();
+  CHECK_NE(channel_, nullptr);
+  ares_destroy(channel_);
+  channel_ = nullptr;
+}
+
+void AresResolver::Restart() {
+  grpc_core::MutexLock lock(&mutex_);
+  polled_fd_factory_ = polled_fd_factory_->NewEmptyInstance();
+  polled_fd_factory_->Initialize(&mutex_, event_engine_.get());
+  CHECK_EQ(channel_, nullptr);
+  absl::Status status =
+      InitAresChannel(dns_server_, *polled_fd_factory_, &channel_);
+  CHECK_OK(status);
+}
+
+#endif  // GRPC_ENABLE_FORK_SUPPORT
+
+void AresResolver::ShutdownLocked(const absl::Status& shutdown_status,
+                                  absl::string_view reason) {
+  if (ares_backup_poll_alarm_handle_.has_value()) {
+    event_engine_->Cancel(*ares_backup_poll_alarm_handle_);
+    ares_backup_poll_alarm_handle_.reset();
+  }
+  for (const auto& fd_node : fd_node_list_) {
+    if (!fd_node->already_shutdown) {
+      GRPC_TRACE_LOG(cares_resolver, INFO) << absl::Substitute(
+          "(EventEngine c-ares resolver) resolver: $0 shutdown fd: $1 ($2)",
+          this, fd_node->polled_fd->GetName(), reason);
+      CHECK(fd_node->polled_fd->ShutdownLocked(shutdown_status));
+      fd_node->already_shutdown = true;
+    }
+  }
+}
+
 }  // namespace grpc_event_engine::experimental
 
 void noop_inject_channel_config(ares_channel* /*channel*/) {}

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

@@ -19,7 +19,6 @@
 #include <utility>
 
 #include "absl/status/status.h"
-#include "src/core/lib/debug/trace.h"
 
 #if GRPC_ARES == 1
 
@@ -42,6 +41,32 @@ namespace grpc_event_engine::experimental {
 
 class AresResolver : public RefCountedDNSResolverInterface {
  public:
+#ifdef GRPC_ENABLE_FORK_SUPPORT
+  // Handle to trigger reinitialization of this AresResolver instance after a
+  // fork(). Avoids global resolver management and POSIX-specific dependencies
+  // within AresResolver.
+  class ReinitHandle {
+   public:
+    static std::shared_ptr<ReinitHandle> New(AresResolver* resolver) {
+      return std::shared_ptr<ReinitHandle>(new ReinitHandle(resolver));
+    }
+
+    ReinitHandle(ReinitHandle&& other) = delete;
+    ReinitHandle(const ReinitHandle& other) = delete;
+    void OnResolverGone();
+    // Clears resources (such as CARES handles) held by the associated resolver.
+    void Reset(const absl::Status& status);
+    // Reinitializes the associated resolver after Reset.
+    void Restart();
+
+   private:
+    explicit ReinitHandle(AresResolver* resolver);
+
+    grpc_core::Mutex mutex_;
+    AresResolver* resolver_ ABSL_GUARDED_BY(&mutex_);
+  };
+#endif  // GRPC_ENABLE_FORK_SUPPORT
+
   static absl::StatusOr<grpc_core::OrphanablePtr<AresResolver>>
   CreateAresResolver(absl::string_view dns_server,
                      std::unique_ptr<GrpcPolledFdFactory> polled_fd_factory,
@@ -49,7 +74,8 @@ class AresResolver : public RefCountedDNSResolverInterface {
 
   // Do not instantiate directly -- use CreateAresResolver() instead.
   AresResolver(std::unique_ptr<GrpcPolledFdFactory> polled_fd_factory,
-               std::shared_ptr<EventEngine> event_engine, ares_channel channel);
+               std::shared_ptr<EventEngine> event_engine, ares_channel channel,
+               absl::string_view dns_server);
   ~AresResolver() override;
   void Orphan() override ABSL_LOCKS_EXCLUDED(mutex_);
 
@@ -60,6 +86,9 @@ class AresResolver : public RefCountedDNSResolverInterface {
                  absl::string_view name) ABSL_LOCKS_EXCLUDED(mutex_) override;
   void LookupTXT(EventEngine::DNSResolver::LookupTXTCallback callback,
                  absl::string_view name) ABSL_LOCKS_EXCLUDED(mutex_) override;
+#ifdef GRPC_ENABLE_FORK_SUPPORT
+  std::weak_ptr<ReinitHandle> GetReinitHandle();
+#endif  // GRPC_ENABLE_FORK_SUPPORT
 
  private:
   // A FdNode saves (not owns) a live socket/fd which c-ares creates, and owns a
@@ -109,6 +138,17 @@ class AresResolver : public RefCountedDNSResolverInterface {
   static void OnTXTDoneLocked(void* arg, int status, int /*timeouts*/,
                               unsigned char* buf,
                               int len) ABSL_NO_THREAD_SAFETY_ANALYSIS;
+#ifdef GRPC_ENABLE_FORK_SUPPORT
+  // Is executed on fork before the poller is restarted. Cleans up the resources
+  // from the previous generation.
+  void Reset(const absl::Status& reason);
+  // Is executed on fork after the poller is restarted. Makes the resolver
+  // usable once more.
+  void Restart();
+#endif  // GRPC_ENABLE_FORK_SUPPORT
+  void ShutdownLocked(const absl::Status& shutdown_status,
+                      absl::string_view reason)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
 
   grpc_core::Mutex mutex_;
   bool shutting_down_ ABSL_GUARDED_BY(mutex_) = false;
@@ -119,6 +159,12 @@ class AresResolver : public RefCountedDNSResolverInterface {
   std::optional<EventEngine::TaskHandle> ares_backup_poll_alarm_handle_
       ABSL_GUARDED_BY(mutex_);
   std::unique_ptr<GrpcPolledFdFactory> polled_fd_factory_;
+#ifdef GRPC_ENABLE_FORK_SUPPORT
+  std::string dns_server_;
+  grpc_core::Mutex reinit_handle_mu_;
+  std::shared_ptr<ReinitHandle> reinit_handle_
+      ABSL_GUARDED_BY(reinit_handle_mu_);
+#endif  // GRPC_ENABLE_FORK_SUPPORT
   std::shared_ptr<EventEngine> event_engine_;
 };
 

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

@@ -31,6 +31,7 @@
 #include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/event_engine/utils.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/useful.h"
 
 #ifndef GRPC_CFSTREAM_MAX_THREADPOOL_SIZE
 #define GRPC_CFSTREAM_MAX_THREADPOOL_SIZE 16u
@@ -58,7 +59,8 @@ struct CFEventEngine::Closure final : public EventEngine::Closure {
 
 CFEventEngine::CFEventEngine()
     : thread_pool_(MakeThreadPool(grpc_core::Clamp(
-          gpr_cpu_num_cores(), 2u, GRPC_CFSTREAM_MAX_THREADPOOL_SIZE))),
+          gpr_cpu_num_cores(), 2u,
+          static_cast<unsigned int>(GRPC_CFSTREAM_MAX_THREADPOOL_SIZE)))),
       timer_manager_(thread_pool_) {}
 
 CFEventEngine::~CFEventEngine() {

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

@@ -26,14 +26,11 @@
 #include "src/core/lib/event_engine/posix_engine/lockfree_event.h"
 #include "src/core/lib/event_engine/posix_engine/posix_engine_closure.h"
 #include "src/core/lib/event_engine/posix_engine/timer_manager.h"
-#include "src/core/lib/surface/init_internally.h"
 #include "src/core/util/sync.h"
 
 namespace grpc_event_engine::experimental {
 
-class CFEventEngine : public EventEngine,
-                      public Scheduler,
-                      public grpc_core::KeepsGrpcInitialized {
+class CFEventEngine : public EventEngine, public Scheduler {
  public:
   CFEventEngine();
   ~CFEventEngine() override;

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

@@ -124,12 +124,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:

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