grpc 1.55.0 → 1.58.0

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

@@ -188,7 +188,7 @@ void CFStreamHandle::Ref(const char* file, int line, const char* reason) {
 void CFStreamHandle::Unref(const char* file, int line, const char* reason) {
   if (grpc_tcp_trace.enabled()) {
     gpr_atm val = gpr_atm_no_barrier_load(&refcount_.count);
-    gpr_log(GPR_DEBUG,
+    gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
             "CFStream Handle unref %p : %s %" PRIdPTR " -> %" PRIdPTR, this,
             reason, val, val - 1);
   }

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

@@ -240,7 +240,7 @@ static void WriteAction(void* arg, grpc_error_handle error) {
 }
 
 static void CFStreamRead(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                         grpc_closure* cb, bool urgent,
+                         grpc_closure* cb, bool /*urgent*/,
                          int /*min_progress_size*/) {
   CFStreamEndpoint* ep_impl = reinterpret_cast<CFStreamEndpoint*>(ep);
   if (grpc_tcp_trace.enabled()) {
@@ -258,7 +258,8 @@ static void CFStreamRead(grpc_endpoint* ep, grpc_slice_buffer* slices,
 }
 
 static void CFStreamWrite(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                          grpc_closure* cb, void* arg, int /*max_frame_size*/) {
+                          grpc_closure* cb, void* /*arg*/,
+                          int /*max_frame_size*/) {
   CFStreamEndpoint* ep_impl = reinterpret_cast<CFStreamEndpoint*>(ep);
   if (grpc_tcp_trace.enabled()) {
     gpr_log(GPR_DEBUG, "CFStream endpoint:%p write (%p, %p) length:%zu",
@@ -304,14 +305,15 @@ absl::string_view CFStreamGetLocalAddress(grpc_endpoint* ep) {
   return ep_impl->local_address;
 }
 
-int CFStreamGetFD(grpc_endpoint* ep) { return 0; }
+int CFStreamGetFD(grpc_endpoint* /*ep*/) { return 0; }
 
-bool CFStreamCanTrackErr(grpc_endpoint* ep) { return false; }
+bool CFStreamCanTrackErr(grpc_endpoint* /*ep*/) { return false; }
 
-void CFStreamAddToPollset(grpc_endpoint* ep, grpc_pollset* pollset) {}
-void CFStreamAddToPollsetSet(grpc_endpoint* ep, grpc_pollset_set* pollset) {}
-void CFStreamDeleteFromPollsetSet(grpc_endpoint* ep,
-                                  grpc_pollset_set* pollset) {}
+void CFStreamAddToPollset(grpc_endpoint* /*ep*/, grpc_pollset* /*pollset*/) {}
+void CFStreamAddToPollsetSet(grpc_endpoint* /*ep*/,
+                             grpc_pollset_set* /*pollset*/) {}
+void CFStreamDeleteFromPollsetSet(grpc_endpoint* /*ep*/,
+                                  grpc_pollset_set* /*pollset*/) {}
 
 static const grpc_endpoint_vtable vtable = {CFStreamRead,
                                             CFStreamWrite,

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_apple.cc

@@ -118,7 +118,7 @@ static void grpc_apple_register_write_stream_queue(
 /// be issued to the run loop when a network event happens and will be driven by
 /// the global run loop thread gGlobalRunLoopThread.
 static void grpc_apple_register_read_stream_run_loop(
-    CFReadStreamRef read_stream, dispatch_queue_t dispatch_queue) {
+    CFReadStreamRef read_stream, dispatch_queue_t /*dispatch_queue*/) {
   GRPC_POLLING_TRACE("Register read stream: %p", read_stream);
   grpc_core::MutexLock lock(&gGlobalRunLoopContext->mu);
   CFReadStreamScheduleWithRunLoop(read_stream, gGlobalRunLoopContext->run_loop,
@@ -131,7 +131,7 @@ static void grpc_apple_register_read_stream_run_loop(
 /// be issued to the run loop when a network event happens, and will be driven
 /// by the global run loop thread gGlobalRunLoopThread.
 static void grpc_apple_register_write_stream_run_loop(
-    CFWriteStreamRef write_stream, dispatch_queue_t dispatch_queue) {
+    CFWriteStreamRef write_stream, dispatch_queue_t /*dispatch_queue*/) {
   GRPC_POLLING_TRACE("Register write stream: %p", write_stream);
   grpc_core::MutexLock lock(&gGlobalRunLoopContext->mu);
   CFWriteStreamScheduleWithRunLoop(
@@ -163,7 +163,7 @@ void grpc_apple_register_write_stream(CFWriteStreamRef write_stream,
 
 /// Drive the run loop in a global singleton thread until the global run loop is
 /// shutdown.
-static void GlobalRunLoopFunc(void* arg) {
+static void GlobalRunLoopFunc(void* /*arg*/) {
   grpc_core::LockableAndReleasableMutexLock lock(&gGlobalRunLoopContext->mu);
   gGlobalRunLoopContext->run_loop = CFRunLoopGetCurrent();
   gGlobalRunLoopContext->init_cv.Signal();
@@ -342,15 +342,15 @@ grpc_pollset_vtable grpc_apple_pollset_vtable = {
 // pollset_set implementation
 
 grpc_pollset_set* pollset_set_create(void) { return nullptr; }
-void pollset_set_destroy(grpc_pollset_set* pollset_set) {}
-void pollset_set_add_pollset(grpc_pollset_set* pollset_set,
-                             grpc_pollset* pollset) {}
-void pollset_set_del_pollset(grpc_pollset_set* pollset_set,
-                             grpc_pollset* pollset) {}
-void pollset_set_add_pollset_set(grpc_pollset_set* bag,
-                                 grpc_pollset_set* item) {}
-void pollset_set_del_pollset_set(grpc_pollset_set* bag,
-                                 grpc_pollset_set* item) {}
+void pollset_set_destroy(grpc_pollset_set* /*pollset_set*/) {}
+void pollset_set_add_pollset(grpc_pollset_set* /*pollset_set*/,
+                             grpc_pollset* /*pollset*/) {}
+void pollset_set_del_pollset(grpc_pollset_set* /*pollset_set*/,
+                             grpc_pollset* /*pollset*/) {}
+void pollset_set_add_pollset_set(grpc_pollset_set* /*bag*/,
+                                 grpc_pollset_set* /*item*/) {}
+void pollset_set_del_pollset_set(grpc_pollset_set* /*bag*/,
+                                 grpc_pollset_set* /*item*/) {}
 
 grpc_pollset_set_vtable grpc_apple_pollset_set_vtable = {
     pollset_set_create,          pollset_set_destroy,

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

@@ -61,6 +61,7 @@
 #include "src/core/lib/iomgr/wakeup_fd_posix.h"
 
 static grpc_wakeup_fd global_wakeup_fd;
+static bool g_is_shutdown = true;
 
 //******************************************************************************
 // Singleton epoll set related fields
@@ -1235,10 +1236,7 @@ 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;
 }
 
 static bool init_epoll1_linux();
@@ -1278,10 +1276,13 @@ const grpc_event_engine_vtable grpc_ev_epoll1_posix = {
 
     is_any_background_poller_thread,
     /* name = */ "epoll1",
-    /* check_engine_available = */ [](bool) { return init_epoll1_linux(); },
-    /* init_engine = */ []() {},
+    /* check_engine_available = */
+    [](bool) { return init_epoll1_linux(); },
+    /* init_engine = */
+    []() { GPR_ASSERT(init_epoll1_linux()); },
     shutdown_background_closure,
-    /* shutdown_engine = */ []() {},
+    /* shutdown_engine = */
+    []() { shutdown_engine(); },
     add_closure_to_background_poller,
 
     fd_set_pre_allocated,
@@ -1291,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);
@@ -1306,6 +1308,7 @@ static void reset_event_manager_on_fork() {
 // Create epoll_fd (epoll_set_init() takes care of that) to make sure epoll
 // support is available
 static bool init_epoll1_linux() {
+  if (!g_is_shutdown) return true;
   if (!grpc_has_wakeup_fd()) {
     gpr_log(GPR_ERROR, "Skipping epoll1 because of no wakeup fd.");
     return false;
@@ -1324,10 +1327,12 @@ 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

@@ -74,15 +74,9 @@ class EventEngineEndpointWrapper {
     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 +113,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++) {
@@ -256,13 +249,20 @@ class EventEngineEndpointWrapper {
     }
   }
 
+  bool CanTrackErrors() {
+    if (EventEngineSupportsFd()) {
+      return reinterpret_cast<PosixEndpointWithFdSupport*>(endpoint_.get())
+          ->CanTrackErrors();
+    } else {
+      return false;
+    }
+  }
+
  private:
   void OnShutdownInternal() {
     {
       grpc_core::MutexLock lock(&mu_);
       fd_ = -1;
-      local_address_ = "";
-      peer_address_ = "";
     }
     endpoint_.reset();
     // For the Ref taken in TriggerShutdown
@@ -277,8 +277,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};
 };
 
@@ -378,7 +380,12 @@ int EndpointGetFd(grpc_endpoint* ep) {
   return eeep->wrapper->Fd();
 }
 
-bool EndpointCanTrackErr(grpc_endpoint* /* ep */) { return false; }
+bool EndpointCanTrackErr(grpc_endpoint* ep) {
+  auto* eeep =
+      reinterpret_cast<EventEngineEndpointWrapper::grpc_event_engine_endpoint*>(
+          ep);
+  return eeep->wrapper->CanTrackErrors();
+}
 
 grpc_endpoint_vtable grpc_event_engine_endpoint_vtable = {
     EndpointRead,
@@ -399,14 +406,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();

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

@@ -329,6 +329,17 @@ class ApplicationCallbackExecCtx {
   static thread_local ApplicationCallbackExecCtx* callback_exec_ctx_;
 };
 
+template <typename F>
+void EnsureRunInExecCtx(F f) {
+  if (ExecCtx::Get() == nullptr) {
+    ApplicationCallbackExecCtx app_ctx;
+    ExecCtx exec_ctx;
+    f();
+  } else {
+    f();
+  }
+}
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_IOMGR_EXEC_CTX_H

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

@@ -43,6 +43,7 @@ static ULONG g_iocp_kick_token;
 static OVERLAPPED g_iocp_custom_overlap;
 
 static gpr_atm g_custom_events = 0;
+static gpr_atm g_pending_socket_shutdowns = 0;
 
 static HANDLE g_iocp;
 
@@ -90,6 +91,7 @@ grpc_iocp_work_status grpc_iocp_work(grpc_core::Timestamp deadline) {
   } else {
     abort();
   }
+  gpr_mu_lock(&socket->state_mu);
   if (socket->shutdown_called) {
     info->bytes_transferred = 0;
     info->wsa_error = WSA_OPERATION_ABORTED;
@@ -100,7 +102,11 @@ grpc_iocp_work_status grpc_iocp_work(grpc_core::Timestamp deadline) {
     info->wsa_error = success ? 0 : WSAGetLastError();
   }
   GPR_ASSERT(overlapped == &info->overlapped);
-  grpc_socket_become_ready(socket, info);
+  bool should_destroy = grpc_socket_become_ready(socket, info);
+  gpr_mu_unlock(&socket->state_mu);
+  if (should_destroy) {
+    grpc_winsocket_finish(socket);
+  }
   return GRPC_IOCP_WORK_WORK;
 }
 
@@ -122,11 +128,13 @@ void grpc_iocp_kick(void) {
 void grpc_iocp_flush(void) {
   grpc_core::ExecCtx exec_ctx;
   grpc_iocp_work_status work_status;
-
+  // This method is called during grpc_shutdown. We make the loop
+  // spin until any pending socket shutdowns are complete.
   do {
     work_status = grpc_iocp_work(grpc_core::Timestamp::InfPast());
   } while (work_status == GRPC_IOCP_WORK_KICK ||
-           grpc_core::ExecCtx::Get()->Flush());
+           grpc_core::ExecCtx::Get()->Flush() ||
+           gpr_atm_acq_load(&g_pending_socket_shutdowns) != 0);
 }
 
 void grpc_iocp_shutdown(void) {
@@ -155,4 +163,17 @@ void grpc_iocp_add_socket(grpc_winsocket* socket) {
   GPR_ASSERT(ret == g_iocp);
 }
 
+void grpc_iocp_register_socket_shutdown_socket_locked(grpc_winsocket* socket) {
+  if (!socket->shutdown_registered) {
+    socket->shutdown_registered = true;
+    gpr_atm_full_fetch_add(&g_pending_socket_shutdowns, 1);
+  }
+}
+
+void grpc_iocp_finish_socket_shutdown(grpc_winsocket* socket) {
+  if (socket->shutdown_registered) {
+    gpr_atm_full_fetch_add(&g_pending_socket_shutdowns, -1);
+  }
+}
+
 #endif  // GRPC_WINSOCK_SOCKET

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

@@ -43,6 +43,17 @@ void grpc_iocp_flush(void);
 void grpc_iocp_shutdown(void);
 void grpc_iocp_add_socket(grpc_winsocket*);
 
+// Register that this socket has started shutting down.
+// This prevents gRPC from completing its own shutdown until this socket's
+// shutdown is finished. IOCP must continue doing work until all such sockets
+// have finished shutting down. The socket's state_mu must be locked.
+void grpc_iocp_register_socket_shutdown_socket_locked(grpc_winsocket* socket);
+
+// Mark that this socket has finished shutting down.
+// The socket's state lock does not need to be held since this function is only
+// called once the socket is ready to be destroyed.
+void grpc_iocp_finish_socket_shutdown(grpc_winsocket* socket);
+
 #endif
 
 #endif  // GRPC_SRC_CORE_LIB_IOMGR_IOCP_WINDOWS_H

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

@@ -73,7 +73,7 @@ static bool apple_iomgr_platform_is_any_background_poller_thread(void) {
 }
 
 static bool apple_iomgr_platform_add_closure_to_background_poller(
-    grpc_closure* closure, grpc_error_handle error) {
+    grpc_closure* /*closure*/, grpc_error_handle /*error*/) {
   return false;
 }
 

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

@@ -86,14 +86,13 @@ void grpc_pollset_destroy(grpc_pollset* pollset);
 // May call grpc_closure_list_run on grpc_closure_list, without holding the
 // pollset
 // lock
-grpc_error_handle grpc_pollset_work(
-    grpc_pollset* pollset, grpc_pollset_worker** worker,
-    grpc_core::Timestamp deadline) GRPC_MUST_USE_RESULT;
+grpc_error_handle grpc_pollset_work(grpc_pollset* pollset,
+                                    grpc_pollset_worker** worker,
+                                    grpc_core::Timestamp deadline);
 
 // Break one polling thread out of polling work for this pollset.
 // If specific_worker is non-NULL, then kick that worker.
 grpc_error_handle grpc_pollset_kick(grpc_pollset* pollset,
-                                    grpc_pollset_worker* specific_worker)
-    GRPC_MUST_USE_RESULT;
+                                    grpc_pollset_worker* specific_worker);
 
 #endif  // GRPC_SRC_CORE_LIB_IOMGR_POLLSET_H

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

@@ -37,6 +37,11 @@
 #define GRPC_HAVE_IP_PKTINFO 1
 #define GRPC_HAVE_MSG_NOSIGNAL 1
 #define GRPC_HAVE_UNIX_SOCKET 1
+#if defined(LINUX_VERSION_CODE) && defined(__GLIBC_PREREQ)
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 9, 0) && __GLIBC_PREREQ(2, 18)
+#define GRPC_HAVE_VSOCK 1
+#endif
+#endif
 #define GRPC_LINUX_EVENTFD 1
 #define GRPC_POSIX_SOCKET 1
 #define GRPC_POSIX_SOCKETUTILS 1
@@ -56,6 +61,11 @@
 #define GRPC_LINUX_ERRQUEUE 1
 #endif  // LINUX_VERSION_CODE >= KERNEL_VERSION(4, 0, 0)
 #endif  // LINUX_VERSION_CODE
+#if defined(LINUX_VERSION_CODE) && defined(__GLIBC_PREREQ)
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 9, 0) && __GLIBC_PREREQ(2, 18)
+#define GRPC_HAVE_VSOCK 1
+#endif
+#endif
 #define GRPC_LINUX_MULTIPOLL_WITH_EPOLL 1
 #define GRPC_POSIX_FORK 1
 #define GRPC_POSIX_HOST_NAME_MAX 1

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

@@ -35,7 +35,9 @@ namespace {
 NoDestruct<std::shared_ptr<DNSResolver>> g_dns_resolver;
 }
 
-constexpr DNSResolver::TaskHandle DNSResolver::kNullHandle;
+const DNSResolver::LookupTaskHandle DNSResolver::LookupTaskHandle::kInvalid = {
+    -1, -1};
+const DNSResolver::TaskHandle DNSResolver::kNullHandle = {0, 0};
 
 void ResetDNSResolver(std::shared_ptr<DNSResolver> resolver) {
   *g_dns_resolver = std::move(resolver);
@@ -43,6 +45,16 @@ void ResetDNSResolver(std::shared_ptr<DNSResolver> resolver) {
 
 std::shared_ptr<DNSResolver> GetDNSResolver() { return *g_dns_resolver; }
 
+bool operator==(const DNSResolver::LookupTaskHandle& lhs,
+                const DNSResolver::LookupTaskHandle& rhs) {
+  return lhs.keys[0] == rhs.keys[0] && lhs.keys[1] == rhs.keys[1];
+}
+
+bool operator!=(const DNSResolver::LookupTaskHandle& lhs,
+                const DNSResolver::LookupTaskHandle& rhs) {
+  return !(lhs == rhs);
+}
+
 std::string DNSResolver::HandleToString(TaskHandle handle) {
   return absl::StrCat("{", handle.keys[0], ",", handle.keys[1], "}");
 }

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

@@ -23,10 +23,12 @@
 
 #include <stddef.h>
 
+#include "absl/container/flat_hash_set.h"
 #include "absl/status/statusor.h"
 
 #include <grpc/event_engine/event_engine.h>
 
+#include "src/core/lib/event_engine/handle_containers.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/pollset_set.h"
@@ -43,9 +45,21 @@ constexpr Duration kDefaultDNSRequestTimeout = Duration::Minutes(2);
 // A singleton class used for async and blocking DNS resolution
 class DNSResolver {
  public:
-  using TaskHandle = ::grpc_event_engine::experimental::EventEngine::
-      DNSResolver::LookupTaskHandle;
-  static constexpr TaskHandle kNullHandle{0, 0};
+  /// Task handle for DNS Resolution requests.
+  struct LookupTaskHandle {
+    intptr_t keys[2];
+    static const LookupTaskHandle kInvalid;
+    friend bool operator==(const LookupTaskHandle& lhs,
+                           const LookupTaskHandle& rhs);
+    friend bool operator!=(const LookupTaskHandle& lhs,
+                           const LookupTaskHandle& rhs);
+  };
+  using TaskHandle = LookupTaskHandle;
+  using TaskHandleSet = absl::flat_hash_set<
+      TaskHandle,
+      grpc_event_engine::experimental::TaskHandleComparator<TaskHandle>::Hash>;
+
+  static const TaskHandle kNullHandle;
 
   virtual ~DNSResolver() {}
 

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

@@ -33,6 +33,10 @@
 #include <sys/types.h>
 #include <unistd.h>
 
+#ifdef GRPC_HAVE_VSOCK
+#include <linux/vm_sockets.h>
+#endif
+
 typedef struct sockaddr grpc_sockaddr;
 typedef struct sockaddr_in grpc_sockaddr_in;
 typedef struct in_addr grpc_in_addr;
@@ -47,6 +51,9 @@ typedef struct in6_addr grpc_in6_addr;
 
 #define GRPC_AF_UNSPEC AF_UNSPEC
 #define GRPC_AF_UNIX AF_UNIX
+#ifdef GRPC_HAVE_VSOCK
+#define GRPC_AF_VSOCK AF_VSOCK
+#endif
 #define GRPC_AF_INET AF_INET
 #define GRPC_AF_INET6 AF_INET6