grpc 1.57.0 → 1.58.0.pre1

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

@@ -0,0 +1,150 @@
+// 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_ARES_RESOLVER_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_ARES_RESOLVER_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/debug/trace.h"
+
+#if GRPC_ARES == 1
+
+#include <list>
+#include <memory>
+
+#include <ares.h>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/container/flat_hash_map.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+#include "absl/types/variant.h"
+
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/support/log.h>
+
+#include "src/core/lib/event_engine/grpc_polled_fd.h"
+#include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/gprpp/sync.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+extern grpc_core::TraceFlag grpc_trace_ares_resolver;
+
+#define GRPC_ARES_RESOLVER_TRACE_LOG(format, ...)                              \
+  do {                                                                         \
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_ares_resolver)) {                   \
+      gpr_log(GPR_INFO, "(EventEngine c-ares resolver) " format, __VA_ARGS__); \
+    }                                                                          \
+  } while (0)
+
+class AresResolver : public grpc_core::InternallyRefCounted<AresResolver> {
+ public:
+  static absl::StatusOr<grpc_core::OrphanablePtr<AresResolver>>
+  CreateAresResolver(absl::string_view dns_server,
+                     std::unique_ptr<GrpcPolledFdFactory> polled_fd_factory,
+                     std::shared_ptr<EventEngine> event_engine);
+
+  // Do not instantiate directly -- use CreateAresResolver() instead.
+  AresResolver(std::unique_ptr<GrpcPolledFdFactory> polled_fd_factory,
+               std::shared_ptr<EventEngine> event_engine, ares_channel channel);
+  ~AresResolver() override;
+  void Orphan() override ABSL_LOCKS_EXCLUDED(mutex_);
+
+  void LookupHostname(absl::string_view name, absl::string_view default_port,
+                      EventEngine::DNSResolver::LookupHostnameCallback callback)
+      ABSL_LOCKS_EXCLUDED(mutex_);
+  void LookupSRV(absl::string_view name,
+                 EventEngine::DNSResolver::LookupSRVCallback callback)
+      ABSL_LOCKS_EXCLUDED(mutex_);
+  void LookupTXT(absl::string_view name,
+                 EventEngine::DNSResolver::LookupTXTCallback callback)
+      ABSL_LOCKS_EXCLUDED(mutex_);
+
+ private:
+  // A FdNode saves (not owns) a live socket/fd which c-ares creates, and owns a
+  // GrpcPolledFd object which has a platform-agnostic interface to interact
+  // with the poller. The liveness of the socket means that c-ares needs us to
+  // monitor r/w events on this socket and notifies c-ares when such events have
+  // happened which we achieve through the GrpcPolledFd object. FdNode also
+  // handles the shutdown (maybe due to socket no longer used, finished request,
+  // cancel or timeout) and the destruction of the poller handle. Note that
+  // FdNode does not own the socket and it's the c-ares' responsibility to
+  // close the socket (possibly through ares_destroy).
+  struct FdNode {
+    FdNode() = default;
+    FdNode(ares_socket_t as, GrpcPolledFd* polled_fd)
+        : as(as), polled_fd(polled_fd) {}
+    ares_socket_t as;
+    std::unique_ptr<GrpcPolledFd> polled_fd;
+    // true if the readable closure has been registered
+    bool readable_registered = false;
+    // true if the writable closure has been registered
+    bool writable_registered = false;
+    bool already_shutdown = false;
+  };
+  using FdNodeList = std::list<std::unique_ptr<FdNode>>;
+
+  using CallbackType =
+      absl::variant<EventEngine::DNSResolver::LookupHostnameCallback,
+                    EventEngine::DNSResolver::LookupSRVCallback,
+                    EventEngine::DNSResolver::LookupTXTCallback>;
+
+  void CheckSocketsLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+  void MaybeStartTimerLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+  void OnReadable(FdNode* fd_node, absl::Status status)
+      ABSL_LOCKS_EXCLUDED(mutex_);
+  void OnWritable(FdNode* fd_node, absl::Status status)
+      ABSL_LOCKS_EXCLUDED(mutex_);
+  void OnAresBackupPollAlarm() ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // These callbacks are invoked from the c-ares library, so disable thread
+  // safety analysis. We are guaranteed to be holding mutex_.
+  static void OnHostbynameDoneLocked(void* arg, int status, int /*timeouts*/,
+                                     struct hostent* hostent)
+      ABSL_NO_THREAD_SAFETY_ANALYSIS;
+  static void OnSRVQueryDoneLocked(void* arg, int status, int /*timeouts*/,
+                                   unsigned char* abuf,
+                                   int alen) ABSL_NO_THREAD_SAFETY_ANALYSIS;
+  static void OnTXTDoneLocked(void* arg, int status, int /*timeouts*/,
+                              unsigned char* buf,
+                              int len) ABSL_NO_THREAD_SAFETY_ANALYSIS;
+
+  grpc_core::Mutex mutex_;
+  bool shutting_down_ ABSL_GUARDED_BY(mutex_) = false;
+  ares_channel channel_ ABSL_GUARDED_BY(mutex_);
+  FdNodeList fd_node_list_ ABSL_GUARDED_BY(mutex_);
+  int id_ ABSL_GUARDED_BY(mutex_) = 0;
+  absl::flat_hash_map<int, CallbackType> callback_map_ ABSL_GUARDED_BY(mutex_);
+  absl::optional<EventEngine::TaskHandle> ares_backup_poll_alarm_handle_
+      ABSL_GUARDED_BY(mutex_);
+  std::unique_ptr<GrpcPolledFdFactory> polled_fd_factory_;
+  std::shared_ptr<EventEngine> event_engine_;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+// Exposed in this header for C-core tests only
+extern void (*event_engine_grpc_ares_test_only_inject_config)(
+    ares_channel* channel);
+
+// Exposed in this header for C-core tests only
+extern bool g_event_engine_grpc_ares_test_only_force_tcp;
+
+#endif  // GRPC_ARES == 1
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_ARES_RESOLVER_H

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

@@ -22,6 +22,7 @@
 
 #include "src/core/lib/event_engine/cf_engine/cf_engine.h"
 #include "src/core/lib/event_engine/cf_engine/cfstream_endpoint.h"
+#include "src/core/lib/event_engine/cf_engine/dns_service_resolver.h"
 #include "src/core/lib/event_engine/posix_engine/timer_manager.h"
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
 #include "src/core/lib/event_engine/thread_pool/thread_pool.h"
@@ -156,9 +157,14 @@ bool CFEventEngine::CancelConnectInternal(ConnectionHandle handle,
 bool CFEventEngine::IsWorkerThread() { grpc_core::Crash("unimplemented"); }
 
 absl::StatusOr<std::unique_ptr<EventEngine::DNSResolver>>
-CFEventEngine::GetDNSResolver(
-    const DNSResolver::ResolverOptions& /* options */) {
-  grpc_core::Crash("unimplemented");
+CFEventEngine::GetDNSResolver(const DNSResolver::ResolverOptions& options) {
+  if (!options.dns_server.empty()) {
+    return absl::InvalidArgumentError(
+        "CFEventEngine does not support custom DNS servers");
+  }
+
+  return std::make_unique<DNSServiceResolver>(
+      std::static_pointer_cast<CFEventEngine>(shared_from_this()));
 }
 
 void CFEventEngine::Run(EventEngine::Closure* closure) {

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

@@ -96,8 +96,8 @@ void CFStreamEndpointImpl::Connect(
   std::string host_string;
   std::string port_string;
   grpc_core::SplitHostPort(host_port.value(), &host_string, &port_string);
-  CFStringRef host = CFStringCreateWithCString(NULL, host_string.c_str(),
-                                               kCFStringEncodingUTF8);
+  CFTypeUniqueRef<CFStringRef> host = CFStringCreateWithCString(
+      NULL, host_string.c_str(), kCFStringEncodingUTF8);
   int port = ResolvedAddressGetPort(peer_address_);
   CFStreamCreatePairWithSocketToHost(NULL, host, port, &cf_read_stream_,
                                      &cf_write_stream_);

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/forkable.cc

@@ -35,6 +35,8 @@
 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};
@@ -58,41 +60,52 @@ void RegisterForkHandlers() {
     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() {
   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() {
   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() {
   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) {
   if (IsForkEnabled()) {
+    GRPC_FORK_TRACE_LOG("Manage forkable::%p", forkable);
     grpc_core::MutexLock lock(g_mu.get());
     g_forkables->push_back(forkable);
   }
@@ -100,6 +113,7 @@ void ManageForkable(Forkable* forkable) {
 
 void StopManagingForkable(Forkable* forkable) {
   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());

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