grpc 1.56.0 → 1.61.0

data/src/core/lib/gprpp/xxhash_inline.h

@@ -0,0 +1,29 @@
+//
+// Copyright 2023 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_GPRPP_XXHASH_INLINE_H
+#define GRPC_SRC_CORE_LIB_GPRPP_XXHASH_INLINE_H
+
+#include <grpc/support/port_platform.h>
+
+// This header is a simple wrapper around the third-party xxhash
+// library, so that we don't need to define XXH_INLINE_ALL in every file
+// that includes xxhash.h.  That definition confuses clang-format's
+// ordering of includes.
+#define XXH_INLINE_ALL
+#include "xxhash.h"
+
+#endif  // GRPC_SRC_CORE_LIB_GPRPP_XXHASH_INLINE_H

data/src/core/lib/http/format_request.cc

@@ -24,7 +24,6 @@
 #include <string.h>
 
 #include <algorithm>
-#include <initializer_list>
 #include <string>
 #include <vector>
 

data/src/core/lib/http/httpcli.cc

@@ -22,7 +22,6 @@
 
 #include <limits.h>
 
-#include <initializer_list>
 #include <string>
 #include <utility>
 
@@ -31,7 +30,6 @@
 #include "absl/strings/str_format.h"
 
 #include <grpc/grpc.h>
-#include <grpc/grpc_security.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>

data/src/core/lib/http/httpcli.h

@@ -100,12 +100,11 @@ class HttpRequest : public InternallyRefCounted<HttpRequest> {
   //   nullptr is treated as insecure credentials.
   //   TODO(yihuaz): disallow nullptr as a value after unsecure builds
   //   are removed.
-  static OrphanablePtr<HttpRequest> Get(
+  GRPC_MUST_USE_RESULT static OrphanablePtr<HttpRequest> Get(
       URI uri, const grpc_channel_args* args, grpc_polling_entity* pollent,
       const grpc_http_request* request, Timestamp deadline,
       grpc_closure* on_done, grpc_http_response* response,
-      RefCountedPtr<grpc_channel_credentials> channel_creds)
-      GRPC_MUST_USE_RESULT;
+      RefCountedPtr<grpc_channel_credentials> channel_creds);
 
   // Asynchronously perform a HTTP POST.
   // 'uri' is the target to make the request to. The scheme field is used to
@@ -126,12 +125,11 @@ class HttpRequest : public InternallyRefCounted<HttpRequest> {
   //   TODO(apolcyn): disallow nullptr as a value after unsecure builds
   //   are removed.
   // Does not support ?var1=val1&var2=val2 in the path.
-  static OrphanablePtr<HttpRequest> Post(
+  GRPC_MUST_USE_RESULT static OrphanablePtr<HttpRequest> Post(
       URI uri, const grpc_channel_args* args, grpc_polling_entity* pollent,
       const grpc_http_request* request, Timestamp deadline,
       grpc_closure* on_done, grpc_http_response* response,
-      RefCountedPtr<grpc_channel_credentials> channel_creds)
-      GRPC_MUST_USE_RESULT;
+      RefCountedPtr<grpc_channel_credentials> channel_creds);
 
   // Asynchronously perform a HTTP PUT.
   // 'uri' is the target to make the request to. The scheme field is used to
@@ -152,12 +150,11 @@ class HttpRequest : public InternallyRefCounted<HttpRequest> {
   //   TODO(apolcyn): disallow nullptr as a value after unsecure builds
   //   are removed.
   // Does not support ?var1=val1&var2=val2 in the path.
-  static OrphanablePtr<HttpRequest> Put(
+  GRPC_MUST_USE_RESULT static OrphanablePtr<HttpRequest> Put(
       URI uri, const grpc_channel_args* args, grpc_polling_entity* pollent,
       const grpc_http_request* request, Timestamp deadline,
       grpc_closure* on_done, grpc_http_response* response,
-      RefCountedPtr<grpc_channel_credentials> channel_creds)
-      GRPC_MUST_USE_RESULT;
+      RefCountedPtr<grpc_channel_credentials> channel_creds);
 
   HttpRequest(URI uri, const grpc_slice& request_text,
               grpc_http_response* response, Timestamp deadline,

data/src/core/lib/http/httpcli_security_connector.cc

@@ -29,6 +29,7 @@
 
 #include <grpc/grpc.h>
 #include <grpc/grpc_security.h>
+#include <grpc/impl/channel_arg_names.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>

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

@@ -278,6 +278,8 @@ void TracedBufferList::ProcessTimestamp(struct sock_extended_err* serr,
       elem = elem->next_;
       continue;
     }
+    g_timestamps_callback(elem->arg_, &(elem->ts_),
+                          absl::DeadlineExceededError("Ack timed out"));
     if (prev != nullptr) {
       prev->next_ = elem->next_;
       delete elem;

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

@@ -27,6 +27,7 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/mpscq.h"
 #include "src/core/lib/iomgr/executor.h"
@@ -50,14 +51,14 @@ static void combiner_finally_exec(grpc_core::Combiner* lock,
                                   grpc_closure* closure,
                                   grpc_error_handle error);
 
-static void offload(void* arg, grpc_error_handle error);
-
-grpc_core::Combiner* grpc_combiner_create(void) {
+grpc_core::Combiner* grpc_combiner_create(
+    std::shared_ptr<grpc_event_engine::experimental::EventEngine>
+        event_engine) {
   grpc_core::Combiner* lock = new grpc_core::Combiner();
+  lock->event_engine = event_engine;
   gpr_ref_init(&lock->refs, 1);
   gpr_atm_no_barrier_store(&lock->state, STATE_UNORPHANED);
   grpc_closure_list_init(&lock->final_list);
-  GRPC_CLOSURE_INIT(&lock->offload, offload, lock, nullptr);
   GRPC_COMBINER_TRACE(gpr_log(GPR_INFO, "C:%p create", lock));
   return lock;
 }
@@ -164,15 +165,18 @@ static void move_next() {
   }
 }
 
-static void offload(void* arg, grpc_error_handle /*error*/) {
-  grpc_core::Combiner* lock = static_cast<grpc_core::Combiner*>(arg);
-  push_last_on_exec_ctx(lock);
-}
-
 static void queue_offload(grpc_core::Combiner* lock) {
   move_next();
+  // Make the combiner look uncontended by storing a non-null value here, so
+  // that we don't immediately offload again.
+  gpr_atm_no_barrier_store(&lock->initiating_exec_ctx_or_null, 1);
   GRPC_COMBINER_TRACE(gpr_log(GPR_INFO, "C:%p queue_offload", lock));
-  grpc_core::Executor::Run(&lock->offload, absl::OkStatus());
+  lock->event_engine->Run([lock] {
+    grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
+    grpc_core::ExecCtx exec_ctx(0);
+    push_last_on_exec_ctx(lock);
+    exec_ctx.Flush();
+  });
 }
 
 bool grpc_combiner_continue_exec_ctx() {
@@ -194,14 +198,10 @@ bool grpc_combiner_continue_exec_ctx() {
                               grpc_core::ExecCtx::Get()->IsReadyToFinish(),
                               lock->time_to_execute_final_list));
 
-  // offload only if all the following conditions are true:
-  // 1. the combiner is contended and has more than one closure to execute
-  // 2. the current execution context needs to finish as soon as possible
-  // 3. the current thread is not a worker for any background poller
-  // 4. the DEFAULT executor is threaded
-  if (contended && grpc_core::ExecCtx::Get()->IsReadyToFinish() &&
-      !grpc_iomgr_platform_is_any_background_poller_thread() &&
-      grpc_core::Executor::IsThreadedDefault()) {
+  // offload only if both (1) the combiner is contended and has more than one
+  // closure to execute, and (2) the current execution context needs to finish
+  // as soon as possible
+  if (contended && grpc_core::ExecCtx::Get()->IsReadyToFinish()) {
     // this execution context wants to move on: schedule remaining work to be
     // picked up on the executor
     queue_offload(lock);
@@ -328,4 +328,10 @@ void Combiner::Run(grpc_closure* closure, grpc_error_handle error) {
 void Combiner::FinallyRun(grpc_closure* closure, grpc_error_handle error) {
   combiner_finally_exec(this, closure, error);
 }
+
+void Combiner::ForceOffload() {
+  gpr_atm_no_barrier_store(&initiating_exec_ctx_or_null, 0);
+  ExecCtx::Get()->SetReadyToFinishFlag();
+}
+
 }  // namespace grpc_core

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

@@ -36,6 +36,8 @@ class Combiner {
   void Run(grpc_closure* closure, grpc_error_handle error);
   // TODO(yashkt) : Remove this method
   void FinallyRun(grpc_closure* closure, grpc_error_handle error);
+  // Force the next combiner execution to be offloaded
+  void ForceOffload();
   Combiner* next_combiner_on_this_exec_ctx = nullptr;
   MultiProducerSingleConsumerQueue queue;
   // either:
@@ -49,8 +51,11 @@ class Combiner {
   gpr_atm state;
   bool time_to_execute_final_list = false;
   grpc_closure_list final_list;
+  // TODO(ctiller): delete this when the combiner_offload_to_event_engine
+  // experiment is removed.
   grpc_closure offload;
   gpr_refcount refs;
+  std::shared_ptr<grpc_event_engine::experimental::EventEngine> event_engine;
 };
 }  // namespace grpc_core
 
@@ -59,9 +64,9 @@ class Combiner {
 // The actual thread executing actions may change over time (but there will only
 // ever be one at a time).
 
-// Initialize the lock, with an optional workqueue to shift load to when
-// necessary
-grpc_core::Combiner* grpc_combiner_create(void);
+// Initialize the lock
+grpc_core::Combiner* grpc_combiner_create(
+    std::shared_ptr<grpc_event_engine::experimental::EventEngine> event_engine);
 
 #ifndef NDEBUG
 #define GRPC_COMBINER_DEBUG_ARGS \

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

@@ -70,12 +70,42 @@ absl::Status grpc_os_error(const grpc_core::DebugLocation& location, int err,
 }
 
 #ifdef GPR_WINDOWS
+std::string WSAErrorToShortDescription(int err) {
+  switch (err) {
+    case WSAEACCES:
+      return "Permission denied";
+    case WSAEFAULT:
+      return "Bad address";
+    case WSAEMFILE:
+      return "Too many open files";
+    case WSAEMSGSIZE:
+      return "Message too long";
+    case WSAENETDOWN:
+      return "Network is down";
+    case WSAENETUNREACH:
+      return "Network is unreachable";
+    case WSAENETRESET:
+      return "Network dropped connection on reset";
+    case WSAECONNABORTED:
+      return "Connection aborted";
+    case WSAECONNRESET:
+      return "Connection reset";
+    case WSAETIMEDOUT:
+      return "Connection timed out";
+    case WSAECONNREFUSED:
+      return "Connection refused";
+    case WSAEHOSTUNREACH:
+      return "No route to host";
+    default:
+      return "WSA Error";
+  };
+}
 // TODO(veblush): lift out of iomgr for use in the WindowsEventEngine
 absl::Status grpc_wsa_error(const grpc_core::DebugLocation& location, int err,
                             absl::string_view call_name) {
   char* utf8_message = gpr_format_message(err);
-  absl::Status s =
-      StatusCreate(absl::StatusCode::kUnavailable, "WSA Error", location, {});
+  absl::Status s = StatusCreate(absl::StatusCode::kUnavailable,
+                                WSAErrorToShortDescription(err), location, {});
   StatusSetInt(&s, grpc_core::StatusIntProperty::kWsaError, err);
   StatusSetInt(&s, grpc_core::StatusIntProperty::kRpcStatus,
                GRPC_STATUS_UNAVAILABLE);

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

@@ -46,8 +46,7 @@ typedef absl::Status grpc_error_handle;
 
 absl::Status grpc_status_create(absl::StatusCode code, absl::string_view msg,
                                 const grpc_core::DebugLocation& location,
-                                size_t children_count,
-                                absl::Status* children) GRPC_MUST_USE_RESULT;
+                                size_t children_count, absl::Status* children);
 
 // Create an error that references some other errors.
 #define GRPC_ERROR_CREATE_REFERENCING(desc, errs, count)                      \
@@ -73,7 +72,7 @@ static absl::Status grpc_status_create_from_vector(
   grpc_status_create_from_vector(DEBUG_LOCATION, desc, error_list)
 
 absl::Status grpc_os_error(const grpc_core::DebugLocation& location, int err,
-                           const char* call_name) GRPC_MUST_USE_RESULT;
+                           const char* call_name);
 
 inline absl::Status grpc_assert_never_ok(absl::Status error) {
   GPR_ASSERT(!error.ok());
@@ -85,7 +84,7 @@ inline absl::Status grpc_assert_never_ok(absl::Status error) {
   grpc_assert_never_ok(grpc_os_error(DEBUG_LOCATION, err, call_name))
 
 absl::Status grpc_wsa_error(const grpc_core::DebugLocation& location, int err,
-                            absl::string_view call_name) GRPC_MUST_USE_RESULT;
+                            absl::string_view call_name);
 
 /// windows only: create an error associated with WSAGetLastError()!=0
 #define GRPC_WSA_ERROR(err, call_name) \
@@ -93,14 +92,14 @@ absl::Status grpc_wsa_error(const grpc_core::DebugLocation& location, int err,
 
 grpc_error_handle grpc_error_set_int(grpc_error_handle src,
                                      grpc_core::StatusIntProperty which,
-                                     intptr_t value) GRPC_MUST_USE_RESULT;
+                                     intptr_t value);
 /// It is an error to pass nullptr as `p`. Caller should allocate a phony
 /// intptr_t for `p`, even if the value of `p` is not used.
 bool grpc_error_get_int(grpc_error_handle error,
                         grpc_core::StatusIntProperty which, intptr_t* p);
-grpc_error_handle grpc_error_set_str(
-    grpc_error_handle src, grpc_core::StatusStrProperty which,
-    absl::string_view str) GRPC_MUST_USE_RESULT;
+grpc_error_handle grpc_error_set_str(grpc_error_handle src,
+                                     grpc_core::StatusStrProperty which,
+                                     absl::string_view str);
 /// Returns false if the specified string is not set.
 bool grpc_error_get_str(grpc_error_handle error,
                         grpc_core::StatusStrProperty which, std::string* str);
@@ -116,8 +115,8 @@ bool grpc_error_get_str(grpc_error_handle error,
 /// returns absl::OkStatus(). 3) If \a src and \a child point to the same error,
 /// returns a single reference. (Note that, 2 references should have been
 /// received to the error in this case.)
-grpc_error_handle grpc_error_add_child(
-    grpc_error_handle src, grpc_error_handle child) GRPC_MUST_USE_RESULT;
+grpc_error_handle grpc_error_add_child(grpc_error_handle src,
+                                       grpc_error_handle child);
 
 bool grpc_log_error(const char* what, grpc_error_handle error, const char* file,
                     int line);

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

@@ -1236,10 +1236,6 @@ static void shutdown_engine(void) {
   fd_global_shutdown();
   pollset_global_shutdown();
   epoll_set_shutdown();
-  if (grpc_core::Fork::Enabled()) {
-    gpr_mu_destroy(&fork_fd_list_mu);
-    grpc_core::Fork::SetResetChildPollingEngineFunc(nullptr);
-  }
   g_is_shutdown = true;
 }
 
@@ -1296,6 +1292,7 @@ const grpc_event_engine_vtable grpc_ev_epoll1_posix = {
 // the global epoll fd. This allows gRPC to shutdown in the child process
 // without interfering with connections or RPCs ongoing in the parent.
 static void reset_event_manager_on_fork() {
+  if (g_is_shutdown) return;
   gpr_mu_lock(&fork_fd_list_mu);
   while (fork_fd_list_head != nullptr) {
     close(fork_fd_list_head->fd);
@@ -1330,9 +1327,10 @@ static bool init_epoll1_linux() {
   }
 
   if (grpc_core::Fork::Enabled()) {
-    gpr_mu_init(&fork_fd_list_mu);
-    grpc_core::Fork::SetResetChildPollingEngineFunc(
-        reset_event_manager_on_fork);
+    if (grpc_core::Fork::RegisterResetChildPollingEngineFunc(
+            reset_event_manager_on_fork)) {
+      gpr_mu_init(&fork_fd_list_mu);
+    }
   }
   g_is_shutdown = false;
   return true;

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

@@ -235,7 +235,7 @@ static int poll_deadline_to_millis_timeout(grpc_core::Timestamp deadline);
 // -- mostly for fd_posix's use.
 static grpc_error_handle pollset_kick_ext(grpc_pollset* p,
                                           grpc_pollset_worker* specific_worker,
-                                          uint32_t flags) GRPC_MUST_USE_RESULT;
+                                          uint32_t flags);
 
 // Return 1 if the pollset has active threads in pollset_work (pollset must
 // be locked)
@@ -1404,10 +1404,11 @@ const grpc_event_engine_vtable grpc_ev_poll_posix = {
         return false;
       }
       if (grpc_core::Fork::Enabled()) {
-        track_fds_for_fork = true;
-        gpr_mu_init(&fork_fd_list_mu);
-        grpc_core::Fork::SetResetChildPollingEngineFunc(
-            reset_event_manager_on_fork);
+        if (grpc_core::Fork::RegisterResetChildPollingEngineFunc(
+                reset_event_manager_on_fork)) {
+          track_fds_for_fork = true;
+          gpr_mu_init(&fork_fd_list_mu);
+        }
       }
       return true;
     },

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

@@ -17,8 +17,11 @@
 
 #include <atomic>
 #include <memory>
+#include <utility>
 
+#include "absl/functional/any_invocable.h"
 #include "absl/status/status.h"
+#include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
 #include <grpc/event_engine/event_engine.h>
@@ -60,29 +63,27 @@ class EventEngineEndpointWrapper {
   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;
+    alignas(SliceBuffer) char read_buffer[sizeof(SliceBuffer)];
+    alignas(SliceBuffer) char write_buffer[sizeof(SliceBuffer)];
   };
 
   explicit EventEngineEndpointWrapper(
       std::unique_ptr<EventEngine::Endpoint> endpoint);
 
+  EventEngine::Endpoint* endpoint() { return endpoint_.get(); }
+
+  std::unique_ptr<EventEngine::Endpoint> ReleaseEndpoint() {
+    return std::move(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 PeerAddress() { return peer_address_; }
 
-  absl::string_view LocalAddress() {
-    grpc_core::MutexLock lock(&mu_);
-    return local_address_;
-  }
+  absl::string_view LocalAddress() { return local_address_; }
 
   void Ref() { refs_.fetch_add(1, std::memory_order_relaxed); }
   void Unref() {
@@ -119,8 +120,7 @@ class EventEngineEndpointWrapper {
     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(),
+      gpr_log(GPR_INFO, "TCP: %p READ error=%s", eeep_->wrapper,
               status.ToString().c_str());
       if (gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
         for (i = 0; i < pending_read_buffer_->count; i++) {
@@ -270,8 +270,6 @@ class EventEngineEndpointWrapper {
     {
       grpc_core::MutexLock lock(&mu_);
       fd_ = -1;
-      local_address_ = "";
-      peer_address_ = "";
     }
     endpoint_.reset();
     // For the Ref taken in TriggerShutdown
@@ -286,8 +284,10 @@ class EventEngineEndpointWrapper {
   grpc_closure* pending_read_cb_;
   grpc_closure* pending_write_cb_;
   grpc_slice_buffer* pending_read_buffer_;
-  std::string peer_address_;
-  std::string local_address_;
+  const std::string peer_address_{
+      ResolvedAddressToURI(endpoint_->GetPeerAddress()).value_or("")};
+  const std::string local_address_{
+      ResolvedAddressToURI(endpoint_->GetLocalAddress()).value_or("")};
   int fd_{-1};
 };
 
@@ -413,14 +413,6 @@ EventEngineEndpointWrapper::EventEngineEndpointWrapper(
       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();
@@ -443,6 +435,30 @@ bool grpc_is_event_engine_endpoint(grpc_endpoint* ep) {
   return ep->vtable == &grpc_event_engine_endpoint_vtable;
 }
 
+EventEngine::Endpoint* grpc_get_wrapped_event_engine_endpoint(
+    grpc_endpoint* ep) {
+  if (!grpc_is_event_engine_endpoint(ep)) {
+    return nullptr;
+  }
+  auto* eeep =
+      reinterpret_cast<EventEngineEndpointWrapper::grpc_event_engine_endpoint*>(
+          ep);
+  return eeep->wrapper->endpoint();
+}
+
+std::unique_ptr<EventEngine::Endpoint> grpc_take_wrapped_event_engine_endpoint(
+    grpc_endpoint* ep) {
+  if (!grpc_is_event_engine_endpoint(ep)) {
+    return nullptr;
+  }
+  auto* eeep =
+      reinterpret_cast<EventEngineEndpointWrapper::grpc_event_engine_endpoint*>(
+          ep);
+  auto endpoint = eeep->wrapper->ReleaseEndpoint();
+  delete eeep->wrapper;
+  return endpoint;
+}
+
 void grpc_event_engine_endpoint_destroy_and_release_fd(
     grpc_endpoint* ep, int* fd, grpc_closure* on_release_fd) {
   auto* eeep =

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

@@ -15,6 +15,8 @@
 #define GRPC_SRC_CORE_LIB_IOMGR_EVENT_ENGINE_SHIMS_ENDPOINT_H
 #include <grpc/support/port_platform.h>
 
+#include <memory>
+
 #include <grpc/event_engine/event_engine.h>
 
 #include "src/core/lib/iomgr/endpoint.h"
@@ -31,6 +33,20 @@ grpc_endpoint* grpc_event_engine_endpoint_create(
 /// Returns true if the passed endpoint is an event engine shim endpoint.
 bool grpc_is_event_engine_endpoint(grpc_endpoint* ep);
 
+/// Returns the wrapped event engine endpoint if the given grpc_endpoint is an
+/// event engine shim endpoint. Otherwise it returns nullptr.
+EventEngine::Endpoint* grpc_get_wrapped_event_engine_endpoint(
+    grpc_endpoint* ep);
+
+/// Transfers ownership of the wrapped event engine endpoint if the given
+/// grpc_endpoint is an event engine shim endpoint. Otherwise it returns
+/// nullptr. If the passed ep wraps an event_engine endpoint, then after this
+/// call, the memory location holding by the passed ep is free'ed.
+/// Its safe to call this function only when there are no pending reads/writes
+/// on the endpoint.
+std::unique_ptr<EventEngine::Endpoint> grpc_take_wrapped_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.

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

@@ -16,6 +16,8 @@
 #include "src/core/lib/iomgr/event_engine_shims/tcp_client.h"
 
 #include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 
 #include <grpc/event_engine/event_engine.h>
@@ -70,8 +72,7 @@ int64_t event_engine_tcp_client_connect(
       },
       CreateResolvedAddress(*addr), config,
       resource_quota != nullptr
-          ? resource_quota->memory_quota()->CreateMemoryOwner(
-                absl::StrCat("tcp-client:", addr_uri.value()))
+          ? resource_quota->memory_quota()->CreateMemoryOwner()
           : grpc_event_engine::experimental::MemoryAllocator(),
       std::max(grpc_core::Duration::Milliseconds(1),
                deadline - grpc_core::Timestamp::Now()));

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

@@ -56,9 +56,21 @@ static void exec_ctx_sched(grpc_closure* closure) {
 
 namespace grpc_core {
 
+#if !defined(_WIN32) || !defined(_DLL)
 thread_local ExecCtx* ExecCtx::exec_ctx_;
 thread_local ApplicationCallbackExecCtx*
     ApplicationCallbackExecCtx::callback_exec_ctx_;
+#else   // _WIN32
+ExecCtx*& ExecCtx::exec_ctx() {
+  static thread_local ExecCtx* exec_ctx;
+  return exec_ctx;
+}
+
+ApplicationCallbackExecCtx*& ApplicationCallbackExecCtx::callback_exec_ctx() {
+  static thread_local ApplicationCallbackExecCtx* callback_exec_ctx;
+  return callback_exec_ctx;
+}
+#endif  // _WIN32
 
 bool ExecCtx::Flush() {
   bool did_something = false;