grpc 1.52.0 → 1.53.0.pre2

data/src/core/lib/iomgr/event_engine_shims/endpoint.cc

@@ -0,0 +1,430 @@
+// Copyright 2022 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>
+
+#include "src/core/lib/iomgr/event_engine_shims/endpoint.h"
+
+#include <atomic>
+#include <memory>
+
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
+
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/impl/codegen/slice.h>
+#include <grpc/slice.h>
+#include <grpc/slice_buffer.h>
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+
+#include "src/core/lib/event_engine/posix.h"
+#include "src/core/lib/event_engine/shim.h"
+#include "src/core/lib/event_engine/tcp_socket_utils.h"
+#include "src/core/lib/event_engine/trace.h"
+#include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/endpoint.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/event_engine_shims/closure.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/iomgr/port.h"
+#include "src/core/lib/slice/slice_string_helpers.h"
+#include "src/core/lib/transport/error_utils.h"
+
+extern grpc_core::TraceFlag grpc_tcp_trace;
+
+namespace grpc_event_engine {
+namespace experimental {
+namespace {
+
+constexpr int64_t kShutdownBit = static_cast<int64_t>(1) << 32;
+
+// A wrapper class to manage Event Engine endpoint ref counting and
+// asynchronous shutdown.
+class EventEngineEndpointWrapper {
+ public:
+  struct grpc_event_engine_endpoint {
+    grpc_endpoint base;
+    EventEngineEndpointWrapper* wrapper;
+    std::aligned_storage<sizeof(SliceBuffer), alignof(SliceBuffer)>::type
+        read_buffer;
+    std::aligned_storage<sizeof(SliceBuffer), alignof(SliceBuffer)>::type
+        write_buffer;
+  };
+
+  explicit EventEngineEndpointWrapper(
+      std::unique_ptr<EventEngine::Endpoint> endpoint);
+
+  int Fd() {
+    grpc_core::MutexLock lock(&mu_);
+    return fd_;
+  }
+
+  absl::string_view PeerAddress() {
+    grpc_core::MutexLock lock(&mu_);
+    return peer_address_;
+  }
+
+  absl::string_view LocalAddress() {
+    grpc_core::MutexLock lock(&mu_);
+    return local_address_;
+  }
+
+  void Ref() { refs_.fetch_add(1, std::memory_order_relaxed); }
+  void Unref() {
+    if (refs_.fetch_sub(1, std::memory_order_acq_rel) == 1) {
+      delete this;
+    }
+  }
+
+  // Returns a managed grpc_endpoint object. It retains ownership of the
+  // object.
+  grpc_endpoint* GetGrpcEndpoint() { return &eeep_->base; }
+
+  // Read using the underlying EventEngine endpoint object.
+  void Read(absl::AnyInvocable<void(absl::Status)> on_read, SliceBuffer* buffer,
+            const EventEngine::Endpoint::ReadArgs* args) {
+    endpoint_->Read(std::move(on_read), buffer, args);
+  }
+
+  // Write using the underlying EventEngine endpoint object
+  void Write(absl::AnyInvocable<void(absl::Status)> on_writable,
+             SliceBuffer* data, const EventEngine::Endpoint::WriteArgs* args) {
+    endpoint_->Write(std::move(on_writable), data, args);
+  }
+
+  // Returns true if the endpoint is not yet shutdown. In that case, it also
+  // acquires a shutdown ref. Otherwise it returns false and doesn't modify
+  // the shutdown ref.
+  bool ShutdownRef() {
+    int64_t curr = shutdown_ref_.load(std::memory_order_acquire);
+    while (true) {
+      if (curr & kShutdownBit) {
+        return false;
+      }
+      if (shutdown_ref_.compare_exchange_strong(curr, curr + 1,
+                                                std::memory_order_acq_rel,
+                                                std::memory_order_relaxed)) {
+        return true;
+      }
+    }
+  }
+
+  // Decrement the shutdown ref. If this is the last shutdown ref, it also
+  // deletes the underlying event engine endpoint. Deletion of the event
+  // engine endpoint should trigger execution of any pending read/write
+  // callbacks with NOT-OK status.
+  void ShutdownUnref() {
+    if (shutdown_ref_.fetch_sub(1, std::memory_order_acq_rel) ==
+        kShutdownBit + 1) {
+      if (EventEngineSupportsFd() && fd_ > 0 && on_release_fd_) {
+        reinterpret_cast<PosixEndpointWithFdSupport*>(endpoint_.get())
+            ->Shutdown(std::move(on_release_fd_));
+      }
+      OnShutdownInternal();
+    }
+  }
+
+  // If trigger shutdown is called the first time, it sets the shutdown bit
+  // and decrements the shutdown ref. If trigger shutdown has been called
+  // before or in parallel, only one of them would win the race. The other
+  // invocation would simply return.
+  void TriggerShutdown(
+      absl::AnyInvocable<void(absl::StatusOr<int>)> on_release_fd) {
+    if (EventEngineSupportsFd()) {
+      on_release_fd_ = std::move(on_release_fd);
+    }
+    int64_t curr = shutdown_ref_.load(std::memory_order_acquire);
+    while (true) {
+      if (curr & kShutdownBit) {
+        return;
+      }
+      if (shutdown_ref_.compare_exchange_strong(curr, curr | kShutdownBit,
+                                                std::memory_order_acq_rel,
+                                                std::memory_order_relaxed)) {
+        Ref();
+        if (shutdown_ref_.fetch_sub(1, std::memory_order_acq_rel) ==
+            kShutdownBit + 1) {
+          if (EventEngineSupportsFd() && fd_ > 0 && on_release_fd_) {
+            reinterpret_cast<PosixEndpointWithFdSupport*>(endpoint_.get())
+                ->Shutdown(std::move(on_release_fd_));
+          }
+          OnShutdownInternal();
+        }
+        return;
+      }
+    }
+  }
+
+ private:
+  void OnShutdownInternal() {
+    {
+      grpc_core::MutexLock lock(&mu_);
+      fd_ = -1;
+      local_address_ = "";
+      peer_address_ = "";
+    }
+    endpoint_.reset();
+    // For the Ref taken in TriggerShutdown
+    Unref();
+  }
+  std::unique_ptr<EventEngine::Endpoint> endpoint_;
+  std::unique_ptr<grpc_event_engine_endpoint> eeep_;
+  std::atomic<int64_t> refs_{1};
+  std::atomic<int64_t> shutdown_ref_{1};
+  absl::AnyInvocable<void(absl::StatusOr<int>)> on_release_fd_;
+  grpc_core::Mutex mu_;
+  std::string peer_address_;
+  std::string local_address_;
+  int fd_{-1};
+};
+
+// Read from the endpoint and place the data in slices slice buffer. The
+// provided closure is also invoked asynchronously.
+void EndpointRead(grpc_endpoint* ep, grpc_slice_buffer* slices,
+                  grpc_closure* cb, bool /* urgent */, int min_progress_size) {
+  auto* eeep =
+      reinterpret_cast<EventEngineEndpointWrapper::grpc_event_engine_endpoint*>(
+          ep);
+  if (!eeep->wrapper->ShutdownRef()) {
+    // Shutdown has already been triggered on the endpoint.
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, cb, absl::CancelledError());
+    return;
+  }
+
+  eeep->wrapper->Ref();
+  EventEngine::Endpoint::ReadArgs read_args = {min_progress_size};
+
+  // TODO(vigneshbabu): Use SliceBufferCast<> here.
+  SliceBuffer* read_buffer = new (&eeep->read_buffer)
+      SliceBuffer(SliceBuffer::TakeCSliceBuffer(*slices));
+  read_buffer->Clear();
+  eeep->wrapper->Read(
+      [eeep, cb, slices](absl::Status status) {
+        auto* read_buffer = reinterpret_cast<SliceBuffer*>(&eeep->read_buffer);
+        grpc_slice_buffer_move_into(read_buffer->c_slice_buffer(), slices);
+        read_buffer->~SliceBuffer();
+        if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
+          size_t i;
+          gpr_log(GPR_INFO, "TCP: %p READ (peer=%s) error=%s", eeep->wrapper,
+                  std::string(eeep->wrapper->PeerAddress()).c_str(),
+                  status.ToString().c_str());
+          if (gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
+            for (i = 0; i < slices->count; i++) {
+              char* dump = grpc_dump_slice(slices->slices[i],
+                                           GPR_DUMP_HEX | GPR_DUMP_ASCII);
+              gpr_log(GPR_DEBUG, "READ DATA: %s", dump);
+              gpr_free(dump);
+            }
+          }
+        }
+        {
+          grpc_core::ApplicationCallbackExecCtx app_ctx;
+          grpc_core::ExecCtx exec_ctx;
+          grpc_core::ExecCtx::Run(DEBUG_LOCATION, cb, status);
+        }
+        // For the ref taken in EndpointRead
+        eeep->wrapper->Unref();
+      },
+      read_buffer, &read_args);
+
+  eeep->wrapper->ShutdownUnref();
+}
+
+// Write the data from slices and invoke the provided closure asynchronously
+// after the write is complete.
+void EndpointWrite(grpc_endpoint* ep, grpc_slice_buffer* slices,
+                   grpc_closure* cb, void* arg, int max_frame_size) {
+  auto* eeep =
+      reinterpret_cast<EventEngineEndpointWrapper::grpc_event_engine_endpoint*>(
+          ep);
+  if (!eeep->wrapper->ShutdownRef()) {
+    // Shutdown has already been triggered on the endpoint.
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, cb, absl::CancelledError());
+    return;
+  }
+
+  eeep->wrapper->Ref();
+  EventEngine::Endpoint::WriteArgs write_args = {arg, max_frame_size};
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
+    size_t i;
+    gpr_log(GPR_INFO, "TCP: %p WRITE (peer=%s)", eeep->wrapper,
+            std::string(eeep->wrapper->PeerAddress()).c_str());
+    if (gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
+      for (i = 0; i < slices->count; i++) {
+        char* dump =
+            grpc_dump_slice(slices->slices[i], GPR_DUMP_HEX | GPR_DUMP_ASCII);
+        gpr_log(GPR_DEBUG, "WRITE DATA: %s", dump);
+        gpr_free(dump);
+      }
+    }
+  }
+
+  // TODO(vigneshbabu): Use SliceBufferCast<> here.
+  SliceBuffer* write_buffer = new (&eeep->write_buffer)
+      SliceBuffer(SliceBuffer::TakeCSliceBuffer(*slices));
+  eeep->wrapper->Write(
+      [eeep, cb](absl::Status status) {
+        auto* write_buffer =
+            reinterpret_cast<SliceBuffer*>(&eeep->write_buffer);
+        write_buffer->~SliceBuffer();
+        if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
+          gpr_log(GPR_INFO, "TCP: %p WRITE (peer=%s) error=%s", eeep->wrapper,
+                  std::string(eeep->wrapper->PeerAddress()).c_str(),
+                  status.ToString().c_str());
+        }
+        {
+          grpc_core::ApplicationCallbackExecCtx app_ctx;
+          grpc_core::ExecCtx exec_ctx;
+          grpc_core::ExecCtx::Run(DEBUG_LOCATION, cb, status);
+        }
+        // For the ref taken in EndpointWrite
+        eeep->wrapper->Unref();
+      },
+      write_buffer, &write_args);
+
+  eeep->wrapper->ShutdownUnref();
+}
+
+void EndpointAddToPollset(grpc_endpoint* /* ep */,
+                          grpc_pollset* /* pollset */) {}
+void EndpointAddToPollsetSet(grpc_endpoint* /* ep */,
+                             grpc_pollset_set* /* pollset */) {}
+void EndpointDeleteFromPollsetSet(grpc_endpoint* /* ep */,
+                                  grpc_pollset_set* /* pollset */) {}
+/// After shutdown, all endpoint operations except destroy are no-op,
+/// and will return some kind of sane default (empty strings, nullptrs, etc).
+/// It is the caller's responsibility to ensure that calls to EndpointShutdown
+/// are synchronized.
+void EndpointShutdown(grpc_endpoint* ep, grpc_error_handle why) {
+  auto* eeep =
+      reinterpret_cast<EventEngineEndpointWrapper::grpc_event_engine_endpoint*>(
+          ep);
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
+    gpr_log(GPR_INFO, "TCP Endpoint %p shutdown why=%s", eeep->wrapper,
+            why.ToString().c_str());
+  }
+  GRPC_EVENT_ENGINE_TRACE("EventEngine::Endpoint %p Shutdown:%s", eeep->wrapper,
+                          why.ToString().c_str());
+  eeep->wrapper->TriggerShutdown(nullptr);
+}
+
+// Attempts to free the underlying data structures.
+void EndpointDestroy(grpc_endpoint* ep) {
+  auto* eeep =
+      reinterpret_cast<EventEngineEndpointWrapper::grpc_event_engine_endpoint*>(
+          ep);
+  GRPC_EVENT_ENGINE_TRACE("EventEngine::Endpoint %p Destroy", eeep->wrapper);
+  eeep->wrapper->Unref();
+}
+
+absl::string_view EndpointGetPeerAddress(grpc_endpoint* ep) {
+  auto* eeep =
+      reinterpret_cast<EventEngineEndpointWrapper::grpc_event_engine_endpoint*>(
+          ep);
+  return eeep->wrapper->PeerAddress();
+}
+
+absl::string_view EndpointGetLocalAddress(grpc_endpoint* ep) {
+  auto* eeep =
+      reinterpret_cast<EventEngineEndpointWrapper::grpc_event_engine_endpoint*>(
+          ep);
+  return eeep->wrapper->LocalAddress();
+}
+
+int EndpointGetFd(grpc_endpoint* ep) {
+  auto* eeep =
+      reinterpret_cast<EventEngineEndpointWrapper::grpc_event_engine_endpoint*>(
+          ep);
+  return eeep->wrapper->Fd();
+}
+
+bool EndpointCanTrackErr(grpc_endpoint* /* ep */) { return false; }
+
+grpc_endpoint_vtable grpc_event_engine_endpoint_vtable = {
+    EndpointRead,
+    EndpointWrite,
+    EndpointAddToPollset,
+    EndpointAddToPollsetSet,
+    EndpointDeleteFromPollsetSet,
+    EndpointShutdown,
+    EndpointDestroy,
+    EndpointGetPeerAddress,
+    EndpointGetLocalAddress,
+    EndpointGetFd,
+    EndpointCanTrackErr};
+
+EventEngineEndpointWrapper::EventEngineEndpointWrapper(
+    std::unique_ptr<EventEngine::Endpoint> endpoint)
+    : endpoint_(std::move(endpoint)),
+      eeep_(std::make_unique<grpc_event_engine_endpoint>()) {
+  eeep_->base.vtable = &grpc_event_engine_endpoint_vtable;
+  eeep_->wrapper = this;
+  auto local_addr = ResolvedAddressToURI(endpoint_->GetLocalAddress());
+  if (local_addr.ok()) {
+    local_address_ = *local_addr;
+  }
+  auto peer_addr = ResolvedAddressToURI(endpoint_->GetPeerAddress());
+  if (peer_addr.ok()) {
+    peer_address_ = *peer_addr;
+  }
+  if (EventEngineSupportsFd()) {
+    fd_ = reinterpret_cast<PosixEndpointWithFdSupport*>(endpoint_.get())
+              ->GetWrappedFd();
+  } else {
+    fd_ = -1;
+  }
+  GRPC_EVENT_ENGINE_TRACE("EventEngine::Endpoint %p Create", eeep_->wrapper);
+}
+
+}  // namespace
+
+grpc_endpoint* grpc_event_engine_endpoint_create(
+    std::unique_ptr<EventEngine::Endpoint> ee_endpoint) {
+  GPR_DEBUG_ASSERT(ee_endpoint != nullptr);
+  auto wrapper = new EventEngineEndpointWrapper(std::move(ee_endpoint));
+  return wrapper->GetGrpcEndpoint();
+}
+
+bool grpc_is_event_engine_endpoint(grpc_endpoint* ep) {
+  return ep->vtable == &grpc_event_engine_endpoint_vtable;
+}
+
+void grpc_event_engine_endpoint_destroy_and_release_fd(
+    grpc_endpoint* ep, int* fd, grpc_closure* on_release_fd) {
+  auto* eeep =
+      reinterpret_cast<EventEngineEndpointWrapper::grpc_event_engine_endpoint*>(
+          ep);
+  if (fd == nullptr || on_release_fd == nullptr) {
+    if (fd != nullptr) {
+      *fd = -1;
+    }
+    eeep->wrapper->TriggerShutdown(nullptr);
+  } else {
+    *fd = -1;
+    eeep->wrapper->TriggerShutdown(
+        [fd, on_release_fd](absl::StatusOr<int> release_fd) {
+          if (release_fd.ok()) {
+            *fd = *release_fd;
+          }
+          RunEventEngineClosure(on_release_fd,
+                                absl_status_to_grpc_error(release_fd.status()));
+        });
+  }
+  eeep->wrapper->Unref();
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine

data/src/core/lib/iomgr/event_engine_shims/endpoint.h

@@ -0,0 +1,43 @@
+// Copyright 2022 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_IOMGR_EVENT_ENGINE_SHIMS_ENDPOINT_H
+#define GRPC_SRC_CORE_LIB_IOMGR_EVENT_ENGINE_SHIMS_ENDPOINT_H
+#include <grpc/support/port_platform.h>
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/iomgr/endpoint.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+/// Creates an internal grpc_endpoint struct from an EventEngine Endpoint.
+/// Server code needs to create grpc_endpoints after the EventEngine has made
+/// connections.
+grpc_endpoint* grpc_event_engine_endpoint_create(
+    std::unique_ptr<EventEngine::Endpoint> ee_endpoint);
+
+/// Returns true if the passed endpoint is an event engine shim endpoint.
+bool grpc_is_event_engine_endpoint(grpc_endpoint* ep);
+
+/// Destroys the passed in event engine shim endpoint and schedules the
+/// asynchronous execution of the on_release_fd callback. The int pointer fd is
+/// set to the underlying endpoint's file descriptor.
+void grpc_event_engine_endpoint_destroy_and_release_fd(
+    grpc_endpoint* ep, int* fd, grpc_closure* on_release_fd);
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_SRC_CORE_LIB_IOMGR_EVENT_ENGINE_SHIMS_ENDPOINT_H

data/src/core/lib/iomgr/event_engine_shims/tcp_client.cc

@@ -0,0 +1,91 @@
+// Copyright 2022 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>
+
+#include "src/core/lib/iomgr/event_engine_shims/tcp_client.h"
+
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
+
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/support/time.h>
+
+#include "src/core/lib/address_utils/sockaddr_utils.h"
+#include "src/core/lib/event_engine/default_event_engine.h"
+#include "src/core/lib/event_engine/resolved_address_internal.h"
+#include "src/core/lib/event_engine/trace.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/endpoint.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/event_engine_shims/endpoint.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/resource_quota/resource_quota.h"
+#include "src/core/lib/transport/error_utils.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+int64_t event_engine_tcp_client_connect(
+    grpc_closure* on_connect, grpc_endpoint** endpoint,
+    const grpc_event_engine::experimental::EndpointConfig& config,
+    const grpc_resolved_address* addr, grpc_core::Timestamp deadline) {
+  auto resource_quota = reinterpret_cast<grpc_core::ResourceQuota*>(
+      config.GetVoidPointer(GRPC_ARG_RESOURCE_QUOTA));
+  auto addr_uri = grpc_sockaddr_to_uri(addr);
+  EventEngine* engine_ptr = reinterpret_cast<EventEngine*>(
+      config.GetVoidPointer(GRPC_INTERNAL_ARG_EVENT_ENGINE));
+  // Keeps the engine alive for some tests that have not otherwise instantiated
+  // an EventEngine
+  std::shared_ptr<EventEngine> keeper;
+  if (engine_ptr == nullptr) {
+    keeper = GetDefaultEventEngine();
+    engine_ptr = keeper.get();
+  }
+  EventEngine::ConnectionHandle handle = engine_ptr->Connect(
+      [on_connect,
+       endpoint](absl::StatusOr<std::unique_ptr<EventEngine::Endpoint>> ep) {
+        grpc_core::ApplicationCallbackExecCtx app_ctx;
+        grpc_core::ExecCtx exec_ctx;
+        absl::Status conn_status = ep.ok() ? absl::OkStatus() : ep.status();
+        if (ep.ok()) {
+          *endpoint = grpc_event_engine_endpoint_create(std::move(*ep));
+        } else {
+          *endpoint = nullptr;
+        }
+        GRPC_EVENT_ENGINE_TRACE("EventEngine::Connect Status: %s",
+                                ep.status().ToString().c_str());
+        grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_connect,
+                                absl_status_to_grpc_error(conn_status));
+      },
+      CreateResolvedAddress(*addr), config,
+      resource_quota != nullptr
+          ? resource_quota->memory_quota()->CreateMemoryOwner(
+                absl::StrCat("tcp-client:", addr_uri.value()))
+          : grpc_event_engine::experimental::MemoryAllocator(),
+      std::max(grpc_core::Duration::Milliseconds(1),
+               deadline - grpc_core::Timestamp::Now()));
+  GRPC_EVENT_ENGINE_TRACE("EventEngine::Connect Peer: %s, handle: %" PRId64,
+                          (*addr_uri).c_str(),
+                          static_cast<int64_t>(handle.keys[0]));
+  return handle.keys[0];
+}
+
+bool event_engine_tcp_client_cancel_connect(int64_t connection_handle) {
+  GRPC_EVENT_ENGINE_TRACE("EventEngine::CancelConnect handle: %" PRId64,
+                          connection_handle);
+  return GetDefaultEventEngine()->CancelConnect(
+      {static_cast<intptr_t>(connection_handle), 0});
+}
+}  // namespace experimental
+}  // namespace grpc_event_engine

data/src/core/lib/iomgr/event_engine_shims/tcp_client.h

@@ -0,0 +1,44 @@
+// Copyright 2022 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_IOMGR_EVENT_ENGINE_SHIMS_TCP_CLIENT_H
+#define GRPC_SRC_CORE_LIB_IOMGR_EVENT_ENGINE_SHIMS_TCP_CLIENT_H
+#include <grpc/support/port_platform.h>
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/iomgr/endpoint.h"
+#include "src/core/lib/iomgr/resolved_address.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+/// Attempts to use event engine to connect to the specified remote address and
+/// invokes the on_connect callback asynchronously upon connection
+/// establishment, failure or timeout. It returns a 64 bit connection handle
+/// which can later be used to cancel an in progress connection attempt.
+int64_t event_engine_tcp_client_connect(grpc_closure* on_connect,
+                                        grpc_endpoint** endpoint,
+                                        const EndpointConfig& config,
+                                        const grpc_resolved_address* addr,
+                                        grpc_core::Timestamp deadline);
+
+/// Attempts to cancel an in progress connection attempt represented by the
+/// passed in connection handle. It returns true if the cancellation attempt
+/// succeeded. Otherwise it returns false.
+bool event_engine_tcp_client_cancel_connect(int64_t connection_handle);
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_SRC_CORE_LIB_IOMGR_EVENT_ENGINE_SHIMS_TCP_CLIENT_H

data/src/core/lib/iomgr/exec_ctx.h

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_CORE_LIB_IOMGR_EXEC_CTX_H
-#define GRPC_CORE_LIB_IOMGR_EXEC_CTX_H
+#ifndef GRPC_SRC_CORE_LIB_IOMGR_EXEC_CTX_H
+#define GRPC_SRC_CORE_LIB_IOMGR_EXEC_CTX_H
 
 #include <grpc/support/port_platform.h>
 
@@ -331,4 +331,4 @@ class ApplicationCallbackExecCtx {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_IOMGR_EXEC_CTX_H
+#endif  // GRPC_SRC_CORE_LIB_IOMGR_EXEC_CTX_H

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

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_CORE_LIB_IOMGR_EXECUTOR_H
-#define GRPC_CORE_LIB_IOMGR_EXECUTOR_H
+#ifndef GRPC_SRC_CORE_LIB_IOMGR_EXECUTOR_H
+#define GRPC_SRC_CORE_LIB_IOMGR_EXECUTOR_H
 
 #include <grpc/support/port_platform.h>
 
@@ -116,4 +116,4 @@ class Executor {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_IOMGR_EXECUTOR_H
+#endif  // GRPC_SRC_CORE_LIB_IOMGR_EXECUTOR_H

data/src/core/lib/iomgr/fork_posix.cc

@@ -100,10 +100,11 @@ void grpc_postfork_child() {
   if (!skipped_handler) {
     grpc_core::Fork::AllowExecCtx();
     grpc_core::ExecCtx exec_ctx;
-    grpc_core::Fork::child_postfork_func reset_polling_engine =
-        grpc_core::Fork::GetResetChildPollingEngineFunc();
-    if (reset_polling_engine != nullptr) {
-      reset_polling_engine();
+    for (auto* reset_polling_engine :
+         grpc_core::Fork::GetResetChildPollingEngineFunc()) {
+      if (reset_polling_engine != nullptr) {
+        reset_polling_engine();
+      }
     }
     grpc_timer_manager_set_threading(true);
     grpc_core::Executor::SetThreadingAll(true);

data/src/core/lib/iomgr/gethostname.h

@@ -16,11 +16,11 @@
 //
 //
 
-#ifndef GRPC_CORE_LIB_IOMGR_GETHOSTNAME_H
-#define GRPC_CORE_LIB_IOMGR_GETHOSTNAME_H
+#ifndef GRPC_SRC_CORE_LIB_IOMGR_GETHOSTNAME_H
+#define GRPC_SRC_CORE_LIB_IOMGR_GETHOSTNAME_H
 
 // Returns the hostname of the local machine.
 // Caller takes ownership of result.
 char* grpc_gethostname();
 
-#endif  // GRPC_CORE_LIB_IOMGR_GETHOSTNAME_H
+#endif  // GRPC_SRC_CORE_LIB_IOMGR_GETHOSTNAME_H