grpc 1.54.3 → 1.58.0

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

@@ -0,0 +1,229 @@
+// Copyright 2023 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 "absl/strings/str_format.h"
+
+#include "src/core/lib/address_utils/parse_address.h"
+#include "src/core/lib/event_engine/cf_engine/dns_service_resolver.h"
+#include "src/core/lib/event_engine/posix_engine/lockfree_event.h"
+#include "src/core/lib/event_engine/tcp_socket_utils.h"
+#include "src/core/lib/event_engine/trace.h"
+#include "src/core/lib/gprpp/host_port.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+void DNSServiceResolverImpl::LookupHostname(
+    EventEngine::DNSResolver::LookupHostnameCallback on_resolve,
+    absl::string_view name, absl::string_view default_port) {
+  GRPC_EVENT_ENGINE_DNS_TRACE(
+      "DNSServiceResolverImpl::LookupHostname: name: %.*s, default_port: %.*s, "
+      "this: %p",
+      static_cast<int>(name.length()), name.data(),
+      static_cast<int>(default_port.length()), default_port.data(), this);
+
+  absl::string_view host;
+  absl::string_view port_string;
+  if (!grpc_core::SplitHostPort(name, &host, &port_string)) {
+    engine_->Run([on_resolve = std::move(on_resolve),
+                  status = absl::InvalidArgumentError(
+                      absl::StrCat("Unparseable name: ", name))]() mutable {
+      on_resolve(status);
+    });
+    return;
+  }
+  GPR_ASSERT(!host.empty());
+  if (port_string.empty()) {
+    if (default_port.empty()) {
+      engine_->Run([on_resolve = std::move(on_resolve),
+                    status = absl::InvalidArgumentError(absl::StrFormat(
+                        "No port in name %s or default_port argument",
+                        name))]() mutable { on_resolve(std::move(status)); });
+      return;
+    }
+    port_string = default_port;
+  }
+
+  int port = 0;
+  if (port_string == "http") {
+    port = 80;
+  } else if (port_string == "https") {
+    port = 443;
+  } else if (!absl::SimpleAtoi(port_string, &port)) {
+    engine_->Run([on_resolve = std::move(on_resolve),
+                  status = absl::InvalidArgumentError(absl::StrCat(
+                      "Failed to parse port in name: ", name))]() mutable {
+      on_resolve(std::move(status));
+    });
+    return;
+  }
+
+  // TODO(yijiem): Change this when refactoring code in
+  // src/core/lib/address_utils to use EventEngine::ResolvedAddress.
+  grpc_resolved_address addr;
+  const std::string hostport = grpc_core::JoinHostPort(host, port);
+  if (grpc_parse_ipv4_hostport(hostport.c_str(), &addr,
+                               /*log_errors=*/false) ||
+      grpc_parse_ipv6_hostport(hostport.c_str(), &addr,
+                               /*log_errors=*/false)) {
+    // Early out if the target is an ipv4 or ipv6 literal, otherwise dns service
+    // responses with kDNSServiceErr_NoSuchRecord
+    std::vector<EventEngine::ResolvedAddress> result;
+    result.emplace_back(reinterpret_cast<sockaddr*>(addr.addr), addr.len);
+    engine_->Run([on_resolve = std::move(on_resolve),
+                  result = std::move(result)]() mutable {
+      on_resolve(std::move(result));
+    });
+    return;
+  }
+
+  DNSServiceRef sdRef;
+  auto host_string = std::string{host};
+  auto error = DNSServiceGetAddrInfo(
+      &sdRef, kDNSServiceFlagsTimeout | kDNSServiceFlagsReturnIntermediates, 0,
+      kDNSServiceProtocol_IPv4 | kDNSServiceProtocol_IPv6, host_string.c_str(),
+      &DNSServiceResolverImpl::ResolveCallback, this /* do not Ref */);
+
+  if (error != kDNSServiceErr_NoError) {
+    engine_->Run([on_resolve = std::move(on_resolve),
+                  status = absl::UnknownError(absl::StrFormat(
+                      "DNSServiceGetAddrInfo failed with error:%d",
+                      error))]() mutable { on_resolve(std::move(status)); });
+    return;
+  }
+
+  grpc_core::ReleasableMutexLock lock(&request_mu_);
+
+  error = DNSServiceSetDispatchQueue(sdRef, queue_);
+  if (error != kDNSServiceErr_NoError) {
+    engine_->Run([on_resolve = std::move(on_resolve),
+                  status = absl::UnknownError(absl::StrFormat(
+                      "DNSServiceSetDispatchQueue failed with error:%d",
+                      error))]() mutable { on_resolve(std::move(status)); });
+    return;
+  }
+
+  requests_.try_emplace(
+      sdRef, DNSServiceRequest{
+                 std::move(on_resolve), static_cast<uint16_t>(port), {}});
+}
+
+/* static */
+void DNSServiceResolverImpl::ResolveCallback(
+    DNSServiceRef sdRef, DNSServiceFlags flags, uint32_t interfaceIndex,
+    DNSServiceErrorType errorCode, const char* hostname,
+    const struct sockaddr* address, uint32_t ttl, void* context) {
+  GRPC_EVENT_ENGINE_DNS_TRACE(
+      "DNSServiceResolverImpl::ResolveCallback: sdRef: %p, flags: %x, "
+      "interface: %d, errorCode: %d, hostname: %s, addressFamily: %d, ttl: "
+      "%d, "
+      "this: %p",
+      sdRef, flags, interfaceIndex, errorCode, hostname, address->sa_family,
+      ttl, context);
+
+  // no need to increase refcount here, since ResolveCallback and Shutdown is
+  // called from the serial queue and it is guarenteed that it won't be called
+  // after the sdRef is deallocated
+  auto that = static_cast<DNSServiceResolverImpl*>(context);
+
+  grpc_core::ReleasableMutexLock lock(&that->request_mu_);
+  auto request_it = that->requests_.find(sdRef);
+  GPR_ASSERT(request_it != that->requests_.end());
+  auto& request = request_it->second;
+
+  if (errorCode != kDNSServiceErr_NoError &&
+      errorCode != kDNSServiceErr_NoSuchRecord) {
+    request.on_resolve(absl::UnknownError(absl::StrFormat(
+        "address lookup failed for %s: errorCode: %d", hostname, errorCode)));
+    that->requests_.erase(request_it);
+    DNSServiceRefDeallocate(sdRef);
+    return;
+  }
+
+  // set received ipv4 or ipv6 response, even for kDNSServiceErr_NoSuchRecord to
+  // mark that the response for the stack is received, it is possible that the
+  // one stack receives some results and the other stack gets
+  // kDNSServiceErr_NoSuchRecord error.
+  if (address->sa_family == AF_INET) {
+    request.has_ipv4_response = true;
+  } else if (address->sa_family == AF_INET6) {
+    request.has_ipv6_response = true;
+  }
+
+  // collect results if there is no error (not kDNSServiceErr_NoSuchRecord)
+  if (errorCode == kDNSServiceErr_NoError) {
+    request.result.emplace_back(address, address->sa_len);
+    auto& resolved_address = request.result.back();
+    if (address->sa_family == AF_INET) {
+      (const_cast<sockaddr_in*>(
+           reinterpret_cast<const sockaddr_in*>(resolved_address.address())))
+          ->sin_port = htons(request.port);
+    } else if (address->sa_family == AF_INET6) {
+      (const_cast<sockaddr_in6*>(
+           reinterpret_cast<const sockaddr_in6*>(resolved_address.address())))
+          ->sin6_port = htons(request.port);
+    }
+
+    GRPC_EVENT_ENGINE_DNS_TRACE(
+        "DNSServiceResolverImpl::ResolveCallback: "
+        "sdRef: %p, hostname: %s, addressPort: %s, this: %p",
+        sdRef, hostname,
+        ResolvedAddressToString(resolved_address).value_or("ERROR").c_str(),
+        context);
+  }
+
+  // received both ipv4 and ipv6 responses, and no more responses (e.g. multiple
+  // IP addresses for a domain name) are coming, finish `LookupHostname` resolve
+  // with the collected results.
+  if (!(flags & kDNSServiceFlagsMoreComing) && request.has_ipv4_response &&
+      request.has_ipv6_response) {
+    if (request.result.empty()) {
+      request.on_resolve(absl::NotFoundError(absl::StrFormat(
+          "address lookup failed for %s: Domain name not found", hostname)));
+    } else {
+      request.on_resolve(std::move(request.result));
+    }
+    that->requests_.erase(request_it);
+    DNSServiceRefDeallocate(sdRef);
+  }
+}
+
+void DNSServiceResolverImpl::Shutdown() {
+  dispatch_async_f(queue_, Ref().release(), [](void* thatPtr) {
+    grpc_core::RefCountedPtr<DNSServiceResolverImpl> that{
+        static_cast<DNSServiceResolverImpl*>(thatPtr)};
+    grpc_core::MutexLock lock(&that->request_mu_);
+    for (auto& kv : that->requests_) {
+      auto& sdRef = kv.first;
+      auto& request = kv.second;
+      GRPC_EVENT_ENGINE_DNS_TRACE(
+          "DNSServiceResolverImpl::Shutdown sdRef: %p, this: %p", sdRef,
+          thatPtr);
+
+      request.on_resolve(
+          absl::CancelledError("DNSServiceResolverImpl::Shutdown"));
+      DNSServiceRefDeallocate(static_cast<DNSServiceRef>(sdRef));
+    }
+    that->requests_.clear();
+  });
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GPR_APPLE

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

@@ -0,0 +1,117 @@
+// Copyright 2023 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_DNS_SERVICE_RESOLVER_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_CF_ENGINE_DNS_SERVICE_RESOLVER_H
+#include <grpc/support/port_platform.h>
+
+#ifdef GPR_APPLE
+
+#include <CoreFoundation/CoreFoundation.h>
+#include <dns_sd.h>
+
+#include "absl/container/flat_hash_map.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/event_engine/cf_engine/cf_engine.h"
+#include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+class DNSServiceResolverImpl
+    : public grpc_core::RefCounted<DNSServiceResolverImpl> {
+  struct DNSServiceRequest {
+    EventEngine::DNSResolver::LookupHostnameCallback on_resolve;
+    uint16_t port;
+    std::vector<EventEngine::ResolvedAddress> result;
+    bool has_ipv4_response = false;
+    bool has_ipv6_response = false;
+  };
+
+ public:
+  explicit DNSServiceResolverImpl(std::shared_ptr<CFEventEngine> engine)
+      : engine_(std::move((engine))) {}
+  ~DNSServiceResolverImpl() override {
+    GPR_ASSERT(requests_.empty());
+    dispatch_release(queue_);
+  }
+
+  void Shutdown();
+
+  void LookupHostname(
+      EventEngine::DNSResolver::LookupHostnameCallback on_resolve,
+      absl::string_view name, absl::string_view default_port);
+
+ private:
+  static void ResolveCallback(DNSServiceRef sdRef, DNSServiceFlags flags,
+                              uint32_t interfaceIndex,
+                              DNSServiceErrorType errorCode,
+                              const char* hostname,
+                              const struct sockaddr* address, uint32_t ttl,
+                              void* context);
+
+ private:
+  std::shared_ptr<CFEventEngine> engine_;
+  // DNSServiceSetDispatchQueue requires a serial dispatch queue
+  dispatch_queue_t queue_ =
+      dispatch_queue_create("dns_service_resolver", nullptr);
+  grpc_core::Mutex request_mu_;
+  absl::flat_hash_map<DNSServiceRef, DNSServiceRequest> requests_
+      ABSL_GUARDED_BY(request_mu_);
+};
+
+class DNSServiceResolver : public EventEngine::DNSResolver {
+ public:
+  explicit DNSServiceResolver(std::shared_ptr<CFEventEngine> engine)
+      : engine_(std::move(engine)),
+        impl_(grpc_core::MakeRefCounted<DNSServiceResolverImpl>(
+            std::move((engine_)))) {}
+
+  ~DNSServiceResolver() override { impl_->Shutdown(); }
+
+  void LookupHostname(
+      EventEngine::DNSResolver::LookupHostnameCallback on_resolve,
+      absl::string_view name, absl::string_view default_port) override {
+    impl_->LookupHostname(std::move(on_resolve), name, default_port);
+  };
+
+  void LookupSRV(EventEngine::DNSResolver::LookupSRVCallback on_resolve,
+                 absl::string_view /* name */) override {
+    engine_->Run([on_resolve = std::move(on_resolve)]() mutable {
+      on_resolve(absl::UnimplementedError(
+          "The DNS Service resolver does not support looking up SRV records"));
+    });
+  }
+
+  void LookupTXT(EventEngine::DNSResolver::LookupTXTCallback on_resolve,
+                 absl::string_view /* name */) override {
+    engine_->Run([on_resolve = std::move(on_resolve)]() mutable {
+      on_resolve(absl::UnimplementedError(
+          "The DNS Service resolver does not support looking up TXT records"));
+    });
+  }
+
+ private:
+  std::shared_ptr<CFEventEngine> engine_;
+  grpc_core::RefCountedPtr<DNSServiceResolverImpl> impl_;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GPR_APPLE
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_CF_ENGINE_DNS_SERVICE_RESOLVER_H

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

@@ -32,6 +32,10 @@
 #include "src/core/lib/gprpp/no_destruct.h"
 #include "src/core/lib/gprpp/sync.h"
 
+#ifdef GRPC_MAXIMIZE_THREADYNESS
+#include "src/core/lib/event_engine/thready_event_engine/thready_event_engine.h"  // IWYU pragma: keep
+#endif
+
 namespace grpc_event_engine {
 namespace experimental {
 
@@ -57,13 +61,21 @@ void EventEngineFactoryReset() {
   g_event_engine->reset();
 }
 
-std::unique_ptr<EventEngine> CreateEventEngine() {
+std::unique_ptr<EventEngine> CreateEventEngineInner() {
   if (auto* factory = g_event_engine_factory.load()) {
     return (*factory)();
   }
   return DefaultEventEngineFactory();
 }
 
+std::unique_ptr<EventEngine> CreateEventEngine() {
+#ifdef GRPC_MAXIMIZE_THREADYNESS
+  return std::make_unique<ThreadyEventEngine>(CreateEventEngineInner());
+#else
+  return CreateEventEngineInner();
+#endif
+}
+
 std::shared_ptr<EventEngine> GetDefaultEventEngine(
     grpc_core::SourceLocation location) {
   grpc_core::MutexLock lock(&*g_mu);

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

@@ -20,7 +20,7 @@
 
 #include <grpc/event_engine/event_engine.h>
 
-#ifdef GPR_WINDOWS
+#if defined(GPR_WINDOWS)
 #include "src/core/lib/event_engine/windows/windows_engine.h"
 
 namespace grpc_event_engine {
@@ -32,7 +32,19 @@ std::unique_ptr<EventEngine> DefaultEventEngineFactory() {
 
 }  // namespace experimental
 }  // namespace grpc_event_engine
-#else  // not GPR_WINDOWS
+#elif defined(GRPC_CFSTREAM)
+#include "src/core/lib/event_engine/cf_engine/cf_engine.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+std::unique_ptr<EventEngine> DefaultEventEngineFactory() {
+  return std::make_unique<CFEventEngine>();
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+#else
 #include "src/core/lib/event_engine/posix_engine/posix_engine.h"
 
 namespace grpc_event_engine {

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

@@ -23,8 +23,6 @@ namespace experimental {
 const EventEngine::TaskHandle EventEngine::TaskHandle::kInvalid = {-1, -1};
 const EventEngine::ConnectionHandle EventEngine::ConnectionHandle::kInvalid = {
     -1, -1};
-const EventEngine::DNSResolver::LookupTaskHandle
-    EventEngine::DNSResolver::LookupTaskHandle::kInvalid = {-1, -1};
 
 bool operator==(const EventEngine::TaskHandle& lhs,
                 const EventEngine::TaskHandle& rhs) {
@@ -46,15 +44,5 @@ bool operator!=(const EventEngine::ConnectionHandle& lhs,
   return !(lhs == rhs);
 }
 
-bool operator==(const EventEngine::DNSResolver::LookupTaskHandle& lhs,
-                const EventEngine::DNSResolver::LookupTaskHandle& rhs) {
-  return lhs.keys[0] == rhs.keys[0] && lhs.keys[1] == rhs.keys[1];
-}
-
-bool operator!=(const EventEngine::DNSResolver::LookupTaskHandle& lhs,
-                const EventEngine::DNSResolver::LookupTaskHandle& rhs) {
-  return !(lhs == rhs);
-}
-
 }  // namespace experimental
 }  // namespace grpc_event_engine

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

@@ -16,18 +16,27 @@
 
 #include "src/core/lib/event_engine/forkable.h"
 
-#ifdef GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK
+#include <grpc/support/log.h>
 
+#ifdef GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK
 #include <pthread.h>
+#endif
+
+#include <algorithm>
+#include <utility>
+#include <vector>
 
-#include "absl/container/flat_hash_set.h"
+#include "absl/base/thread_annotations.h"
 
+#include "src/core/lib/config/config_vars.h"
 #include "src/core/lib/gprpp/no_destruct.h"
 #include "src/core/lib/gprpp/sync.h"
 
 namespace grpc_event_engine {
 namespace experimental {
 
+grpc_core::TraceFlag grpc_trace_fork(false, "fork");
+
 namespace {
 grpc_core::NoDestruct<grpc_core::Mutex> g_mu;
 bool g_registered ABSL_GUARDED_BY(g_mu){false};
@@ -35,6 +44,11 @@ bool g_registered ABSL_GUARDED_BY(g_mu){false};
 // 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);
+
+bool IsForkEnabled() {
+  static bool enabled = grpc_core::ConfigVars::Get().EnableForkSupport();
+  return enabled;
+}
 }  // namespace
 
 Forkable::Forkable() { ManageForkable(this); }
@@ -42,65 +56,70 @@ Forkable::Forkable() { ManageForkable(this); }
 Forkable::~Forkable() { StopManagingForkable(this); }
 
 void RegisterForkHandlers() {
-  grpc_core::MutexLock lock(g_mu.get());
-  if (!std::exchange(g_registered, true)) {
-    pthread_atfork(PrepareFork, PostforkParent, PostforkChild);
+  if (IsForkEnabled()) {
+    grpc_core::MutexLock lock(g_mu.get());
+    if (!std::exchange(g_registered, true)) {
+#ifdef GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK
+      GRPC_FORK_TRACE_LOG_STRING("RegisterForkHandlers");
+      pthread_atfork(PrepareFork, PostforkParent, PostforkChild);
+#endif
+    }
   }
-};
+}
 
 void PrepareFork() {
-  grpc_core::MutexLock lock(g_mu.get());
-  for (auto forkable_iter = g_forkables->rbegin();
-       forkable_iter != g_forkables->rend(); ++forkable_iter) {
-    (*forkable_iter)->PrepareFork();
+  if (IsForkEnabled()) {
+    GRPC_FORK_TRACE_LOG_STRING("PrepareFork");
+    grpc_core::MutexLock lock(g_mu.get());
+    for (auto forkable_iter = g_forkables->rbegin();
+         forkable_iter != g_forkables->rend(); ++forkable_iter) {
+      (*forkable_iter)->PrepareFork();
+    }
+    GRPC_FORK_TRACE_LOG_STRING("PrepareFork finished");
   }
 }
+
 void PostforkParent() {
-  grpc_core::MutexLock lock(g_mu.get());
-  for (auto* forkable : *g_forkables) {
-    forkable->PostforkParent();
+  if (IsForkEnabled()) {
+    GRPC_FORK_TRACE_LOG_STRING("PostforkParent");
+    grpc_core::MutexLock lock(g_mu.get());
+    for (auto* forkable : *g_forkables) {
+      GRPC_FORK_TRACE_LOG("Calling PostforkParent for forkable::%p", forkable);
+      forkable->PostforkParent();
+    }
+    GRPC_FORK_TRACE_LOG_STRING("PostforkParent finished");
   }
 }
 
 void PostforkChild() {
-  grpc_core::MutexLock lock(g_mu.get());
-  for (auto* forkable : *g_forkables) {
-    forkable->PostforkChild();
+  if (IsForkEnabled()) {
+    GRPC_FORK_TRACE_LOG_STRING("PostforkChild");
+    grpc_core::MutexLock lock(g_mu.get());
+    for (auto* forkable : *g_forkables) {
+      GRPC_FORK_TRACE_LOG("Calling PostforkChild for forkable::%p", forkable);
+      forkable->PostforkChild();
+    }
+    GRPC_FORK_TRACE_LOG_STRING("PostforkChild finished");
   }
 }
 
 void ManageForkable(Forkable* forkable) {
-  grpc_core::MutexLock lock(g_mu.get());
-  g_forkables->push_back(forkable);
+  if (IsForkEnabled()) {
+    GRPC_FORK_TRACE_LOG("Manage forkable::%p", forkable);
+    grpc_core::MutexLock lock(g_mu.get());
+    g_forkables->push_back(forkable);
+  }
 }
 
 void StopManagingForkable(Forkable* forkable) {
-  grpc_core::MutexLock lock(g_mu.get());
-  auto iter = std::find(g_forkables->begin(), g_forkables->end(), forkable);
-  GPR_ASSERT(iter != g_forkables->end());
-  g_forkables->erase(iter);
+  if (IsForkEnabled()) {
+    GRPC_FORK_TRACE_LOG("Stop managing forkable::%p", forkable);
+    grpc_core::MutexLock lock(g_mu.get());
+    auto iter = std::find(g_forkables->begin(), g_forkables->end(), forkable);
+    GPR_ASSERT(iter != g_forkables->end());
+    g_forkables->erase(iter);
+  }
 }
 
 }  // namespace experimental
 }  // namespace grpc_event_engine
-
-#else  // GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK
-
-namespace grpc_event_engine {
-namespace experimental {
-
-Forkable::Forkable() {}
-Forkable::~Forkable() {}
-
-void RegisterForkHandlers() {}
-void PrepareFork() {}
-void PostforkParent() {}
-void PostforkChild() {}
-
-void ManageForkable(Forkable* /* forkable */) {}
-void StopManagingForkable(Forkable* /* forkable */) {}
-
-}  // namespace experimental
-}  // namespace grpc_event_engine
-
-#endif  // GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK

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

@@ -16,9 +16,24 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <grpc/support/log.h>
+
+#include "src/core/lib/debug/trace.h"
+
 namespace grpc_event_engine {
 namespace experimental {
 
+extern grpc_core::TraceFlag grpc_trace_fork;
+
+#define GRPC_FORK_TRACE_LOG(format, ...)                 \
+  do {                                                   \
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_fork)) {      \
+      gpr_log(GPR_DEBUG, "[fork] " format, __VA_ARGS__); \
+    }                                                    \
+  } while (0)
+
+#define GRPC_FORK_TRACE_LOG_STRING(format) GRPC_FORK_TRACE_LOG("%s", format)
+
 // Register fork handlers with the system, enabling fork support.
 //
 // This provides pthread-based support for fork events. Any objects that

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

@@ -0,0 +1,73 @@
+// Copyright 2023 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_GRPC_POLLED_FD_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_GRPC_POLLED_FD_H
+
+#include <grpc/support/port_platform.h>
+
+#if GRPC_ARES == 1
+
+#include <ares.h>
+
+#include "absl/functional/any_invocable.h"
+#include "absl/status/status.h"
+
+#include "src/core/lib/iomgr/error.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+// A wrapped fd that integrates with the EventEngine poller of the current
+// platform. A GrpcPolledFd knows how to create grpc platform-specific poller
+// handle from "ares_socket_t" sockets, and then sign up for
+// readability/writeability with that poller handle, and do shutdown and
+// destruction.
+class GrpcPolledFd {
+ public:
+  virtual ~GrpcPolledFd() {}
+  // Called when c-ares library is interested and there's no pending callback
+  virtual void RegisterForOnReadableLocked(
+      absl::AnyInvocable<void(absl::Status)> read_closure) = 0;
+  // Called when c-ares library is interested and there's no pending callback
+  virtual void RegisterForOnWriteableLocked(
+      absl::AnyInvocable<void(absl::Status)> write_closure) = 0;
+  // Indicates if there is data left even after just being read from
+  virtual bool IsFdStillReadableLocked() = 0;
+  // Called once and only once. Must cause cancellation of any pending
+  // read/write callbacks.
+  virtual void ShutdownLocked(grpc_error_handle error) = 0;
+  // Get the underlying ares_socket_t that this was created from
+  virtual ares_socket_t GetWrappedAresSocketLocked() = 0;
+  // A unique name, for logging
+  virtual const char* GetName() const = 0;
+};
+
+// A GrpcPolledFdFactory is 1-to-1 with and owned by a GrpcAresRequest. It knows
+// how to create GrpcPolledFd's for the current platform, and the
+// GrpcAresRequest uses it for all of its fd's.
+class GrpcPolledFdFactory {
+ public:
+  virtual ~GrpcPolledFdFactory() {}
+  // Creates a new wrapped fd for the current platform
+  virtual GrpcPolledFd* NewGrpcPolledFdLocked(ares_socket_t as) = 0;
+  // Optionally configures the ares channel after creation
+  virtual void ConfigureAresChannelLocked(ares_channel channel) = 0;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_ARES == 1
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_GRPC_POLLED_FD_H