grpc 1.54.3 → 1.59.2

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

@@ -23,6 +23,11 @@
 
 #include <limits>
 
+#if __APPLE__
+// Provides TARGET_OS_IPHONE
+#include <TargetConditionals.h>
+#endif
+
 #include <grpc/impl/grpc_types.h>
 #include <grpc/support/atm.h>
 #include <grpc/support/cpu.h>
@@ -36,6 +41,14 @@
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/closure.h"
 
+#if !defined(_WIN32) || !defined(_DLL)
+#define EXEC_CTX exec_ctx_
+#define CALLBACK_EXEC_CTX callback_exec_ctx_
+#else
+#define EXEC_CTX exec_ctx()
+#define CALLBACK_EXEC_CTX callback_exec_ctx()
+#endif
+
 /// A combiner represents a list of work to be executed later.
 /// Forward declared here to avoid a circular dependency with combiner.h.
 typedef struct grpc_combiner grpc_combiner;
@@ -94,7 +107,7 @@ class Combiner;
 ///               since that implies a core re-entry outside of application
 ///               callbacks.
 ///
-class ExecCtx {
+class GRPC_DLL ExecCtx {
  public:
   /// Default Constructor
 
@@ -125,13 +138,6 @@ class ExecCtx {
   ExecCtx(const ExecCtx&) = delete;
   ExecCtx& operator=(const ExecCtx&) = delete;
 
-  unsigned starting_cpu() {
-    if (starting_cpu_ == std::numeric_limits<unsigned>::max()) {
-      starting_cpu_ = gpr_cpu_current_cpu();
-    }
-    return starting_cpu_;
-  }
-
   struct CombinerData {
     // currently active combiner: updated only via combiner.c
     Combiner* active_combiner;
@@ -176,17 +182,32 @@ class ExecCtx {
     }
   }
 
+  void SetReadyToFinishFlag() { flags_ |= GRPC_EXEC_CTX_FLAG_IS_FINISHED; }
+
   Timestamp Now() { return Timestamp::Now(); }
-  void InvalidateNow() { time_cache_.InvalidateCache(); }
+
+  void InvalidateNow() {
+#if !TARGET_OS_IPHONE
+    time_cache_.InvalidateCache();
+#endif
+  }
+
   void SetNowIomgrShutdown() {
+#if !TARGET_OS_IPHONE
     // We get to do a test only set now on this path just because iomgr
     // is getting removed and no point adding more interfaces for it.
     time_cache_.TestOnlySetNow(Timestamp::InfFuture());
+#endif
+  }
+
+  void TestOnlySetNow(Timestamp now) {
+#if !TARGET_OS_IPHONE
+    time_cache_.TestOnlySetNow(now);
+#endif
   }
-  void TestOnlySetNow(Timestamp now) { time_cache_.TestOnlySetNow(now); }
 
   /// Gets pointer to current exec_ctx.
-  static ExecCtx* Get() { return exec_ctx_; }
+  static ExecCtx* Get() { return EXEC_CTX; }
 
   static void Run(const DebugLocation& location, grpc_closure* closure,
                   grpc_error_handle error);
@@ -201,17 +222,23 @@ class ExecCtx {
   static void operator delete(void* /* p */) { abort(); }
 
  private:
-  /// Set exec_ctx_ to exec_ctx.
-  static void Set(ExecCtx* exec_ctx) { exec_ctx_ = exec_ctx; }
+  /// Set EXEC_CTX to ctx.
+  static void Set(ExecCtx* ctx) { EXEC_CTX = ctx; }
 
   grpc_closure_list closure_list_ = GRPC_CLOSURE_LIST_INIT;
   CombinerData combiner_data_ = {nullptr, nullptr};
   uintptr_t flags_;
 
-  unsigned starting_cpu_ = std::numeric_limits<unsigned>::max();
-
+#if !TARGET_OS_IPHONE
   ScopedTimeCache time_cache_;
+#endif
+
+#if !defined(_WIN32) || !defined(_DLL)
   static thread_local ExecCtx* exec_ctx_;
+#else
+  // cannot be thread_local data member (e.g. exec_ctx_) on windows
+  static ExecCtx*& exec_ctx();
+#endif
   ExecCtx* last_exec_ctx_ = Get();
 };
 
@@ -262,7 +289,7 @@ class ExecCtx {
 ///
 ///
 
-class ApplicationCallbackExecCtx {
+class GRPC_DLL ApplicationCallbackExecCtx {
  public:
   /// Default Constructor
   ApplicationCallbackExecCtx() { Set(this, flags_); }
@@ -282,7 +309,7 @@ class ApplicationCallbackExecCtx {
         }
         (*f->functor_run)(f, f->internal_success);
       }
-      callback_exec_ctx_ = nullptr;
+      CALLBACK_EXEC_CTX = nullptr;
       if (!(GRPC_APP_CALLBACK_EXEC_CTX_FLAG_IS_INTERNAL_THREAD & flags_)) {
         Fork::DecExecCtxCount();
       }
@@ -294,14 +321,14 @@ class ApplicationCallbackExecCtx {
 
   uintptr_t Flags() { return flags_; }
 
-  static ApplicationCallbackExecCtx* Get() { return callback_exec_ctx_; }
+  static ApplicationCallbackExecCtx* Get() { return CALLBACK_EXEC_CTX; }
 
   static void Set(ApplicationCallbackExecCtx* exec_ctx, uintptr_t flags) {
     if (Get() == nullptr) {
       if (!(GRPC_APP_CALLBACK_EXEC_CTX_FLAG_IS_INTERNAL_THREAD & flags)) {
         Fork::IncExecCtxCount();
       }
-      callback_exec_ctx_ = exec_ctx;
+      CALLBACK_EXEC_CTX = exec_ctx;
     }
   }
 
@@ -326,9 +353,29 @@ class ApplicationCallbackExecCtx {
   uintptr_t flags_{0u};
   grpc_completion_queue_functor* head_{nullptr};
   grpc_completion_queue_functor* tail_{nullptr};
+
+#if !defined(_WIN32) || !defined(_DLL)
   static thread_local ApplicationCallbackExecCtx* callback_exec_ctx_;
+#else
+  // cannot be thread_local data member (e.g. callback_exec_ctx_) on windows
+  static ApplicationCallbackExecCtx*& callback_exec_ctx();
+#endif
 };
 
+template <typename F>
+void EnsureRunInExecCtx(F f) {
+  if (ExecCtx::Get() == nullptr) {
+    ApplicationCallbackExecCtx app_ctx;
+    ExecCtx exec_ctx;
+    f();
+  } else {
+    f();
+  }
+}
+
+#undef EXEC_CTX
+#undef CALLBACK_EXEC_CTX
+
 }  // 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/polling_entity.cc

@@ -98,3 +98,13 @@ void grpc_polling_entity_del_from_pollset_set(grpc_polling_entity* pollent,
         absl::StrFormat("Invalid grpc_polling_entity tag '%d'", pollent->tag));
   }
 }
+
+std::string grpc_polling_entity_string(grpc_polling_entity* pollent) {
+  if (pollent->tag == GRPC_POLLS_POLLSET) {
+    return absl::StrFormat("pollset:%p", pollent->pollent.pollset);
+  } else if (pollent->tag == GRPC_POLLS_POLLSET_SET) {
+    return absl::StrFormat("pollset_set:%p", pollent->pollent.pollset_set);
+  } else {
+    return absl::StrFormat("invalid_tag:%d", pollent->tag);
+  }
+}

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

@@ -66,6 +66,8 @@ void grpc_polling_entity_add_to_pollset_set(grpc_polling_entity* pollent,
 void grpc_polling_entity_del_from_pollset_set(grpc_polling_entity* pollent,
                                               grpc_pollset_set* pss_dst);
 
+std::string grpc_polling_entity_string(grpc_polling_entity* pollent);
+
 namespace grpc_core {
 template <>
 struct ContextType<grpc_polling_entity> {};

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
@@ -199,6 +209,20 @@
 #define GRPC_POSIX_SOCKET 1
 #define GRPC_POSIX_SOCKETUTILS 1
 #define GRPC_POSIX_WAKEUP_FD 1
+#elif defined(__QNX__) || defined(__QNXNTO__)
+#define GRPC_HAVE_ARPA_NAMESER 1
+#define GRPC_HAVE_IFADDRS 1
+#define GRPC_HAVE_IPV6_RECVPKTINFO 1
+#define GRPC_HAVE_IP_PKTINFO 1
+#define GRPC_HAVE_MSG_NOSIGNAL 1
+#define GRPC_HAVE_UNIX_SOCKET 1
+// TODO(rbyshliaha): Find a way to understand if VSOCK package is installed in
+//                   a toolchain to enable GRPC_HAVE_VSOCK.
+#define GRPC_POSIX_SOCKET 1
+#define GRPC_POSIX_WAKEUP_FD 1
+#define GRPC_POSIX_NO_SPECIAL_WAKEUP_FD 1
+#define GRPC_POSIX_SOCKETUTILS 1
+#define GRPC_POSIX_SYSCONF 1
 #elif !defined(GPR_NO_AUTODETECT_PLATFORM)
 #error "Platform not recognized"
 #endif

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
 

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

@@ -249,6 +249,35 @@ grpc_error_handle grpc_set_socket_low_latency(int fd, int low_latency) {
   return absl::OkStatus();
 }
 
+/* Set Differentiated Services Code Point (DSCP) */
+grpc_error_handle grpc_set_socket_dscp(int fd, int dscp) {
+  if (dscp == grpc_core::PosixTcpOptions::kDscpNotSet) {
+    return absl::OkStatus();
+  }
+  // The TOS/TrafficClass byte consists of following bits:
+  // | 7 6 5 4 3 2 | 1 0 |
+  // |    DSCP     | ECN |
+  int value = dscp << 2;
+
+  int optval;
+  socklen_t optlen = sizeof(optval);
+  // Get ECN bits from current IP_TOS value unless IPv6 only
+  if (0 == getsockopt(fd, IPPROTO_IP, IP_TOS, &optval, &optlen)) {
+    value |= (optval & 0x3);
+    if (0 != setsockopt(fd, IPPROTO_IP, IP_TOS, &value, sizeof(value))) {
+      return GRPC_OS_ERROR(errno, "setsockopt(IP_TOS)");
+    }
+  }
+  // Get ECN from current Traffic Class value if IPv6 is available
+  if (0 == getsockopt(fd, IPPROTO_IPV6, IPV6_TCLASS, &optval, &optlen)) {
+    value |= (optval & 0x3);
+    if (0 != setsockopt(fd, IPPROTO_IPV6, IPV6_TCLASS, &value, sizeof(value))) {
+      return GRPC_OS_ERROR(errno, "setsockopt(IPV6_TCLASS)");
+    }
+  }
+  return absl::OkStatus();
+}
+
 // The default values for TCP_USER_TIMEOUT are currently configured to be in
 // line with the default values of KEEPALIVE_TIMEOUT as proposed in
 // https://github.com/grpc/proposal/blob/master/A18-tcp-user-timeout.md
@@ -357,8 +386,10 @@ grpc_error_handle grpc_set_socket_tcp_user_timeout(
           return absl::OkStatus();
         }
         if (newval != timeout) {
-          // Do not fail on failing to set TCP_USER_TIMEOUT for now.
-          gpr_log(GPR_ERROR, "Failed to set TCP_USER_TIMEOUT");
+          gpr_log(GPR_INFO,
+                  "Setting TCP_USER_TIMEOUT to value %d ms. Actual "
+                  "TCP_USER_TIMEOUT value is %d ms",
+                  timeout, newval);
           return absl::OkStatus();
         }
       }

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

@@ -77,6 +77,9 @@ PosixTcpOptions TcpOptionsFromEndpointConfig(const EndpointConfig& config) {
   options.tcp_tx_zerocopy_max_simultaneous_sends =
       AdjustValue(PosixTcpOptions::kDefaultMaxSends, 0, INT_MAX,
                   config.GetInt(GRPC_ARG_TCP_TX_ZEROCOPY_MAX_SIMULT_SENDS));
+  options.tcp_receive_buffer_size =
+      AdjustValue(PosixTcpOptions::kReadBufferSizeUnset, 0, INT_MAX,
+                  config.GetInt(GRPC_ARG_TCP_RECEIVE_BUFFER_SIZE));
   options.tcp_tx_zero_copy_enabled =
       (AdjustValue(PosixTcpOptions::kZerocpTxEnabledDefault, 0, 1,
                    config.GetInt(GRPC_ARG_TCP_TX_ZEROCOPY_ENABLED)) != 0);
@@ -90,6 +93,8 @@ PosixTcpOptions TcpOptionsFromEndpointConfig(const EndpointConfig& config) {
   options.allow_reuse_port =
       (AdjustValue(0, 1, INT_MAX, config.GetInt(GRPC_ARG_ALLOW_REUSEPORT)) !=
        0);
+  options.dscp = AdjustValue(PosixTcpOptions::kDscpNotSet, 0, 63,
+                             config.GetInt(GRPC_ARG_DSCP));
 
   if (options.tcp_min_read_chunk_size > options.tcp_max_read_chunk_size) {
     options.tcp_min_read_chunk_size = options.tcp_max_read_chunk_size;

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

@@ -49,14 +49,19 @@ struct PosixTcpOptions {
   static constexpr int kMaxChunkSize = 32 * 1024 * 1024;
   static constexpr int kDefaultMaxSends = 4;
   static constexpr size_t kDefaultSendBytesThreshold = 16 * 1024;
+  // Let the system decide the proper buffer size.
+  static constexpr int kReadBufferSizeUnset = -1;
+  static constexpr int kDscpNotSet = -1;
   int tcp_read_chunk_size = kDefaultReadChunkSize;
   int tcp_min_read_chunk_size = kDefaultMinReadChunksize;
   int tcp_max_read_chunk_size = kDefaultMaxReadChunksize;
   int tcp_tx_zerocopy_send_bytes_threshold = kDefaultSendBytesThreshold;
   int tcp_tx_zerocopy_max_simultaneous_sends = kDefaultMaxSends;
+  int tcp_receive_buffer_size = kReadBufferSizeUnset;
   bool tcp_tx_zero_copy_enabled = kZerocpTxEnabledDefault;
   int keep_alive_time_ms = 0;
   int keep_alive_timeout_ms = 0;
+  int dscp = kDscpNotSet;
   bool expand_wildcard_addrs = false;
   bool allow_reuse_port = false;
   RefCountedPtr<ResourceQuota> resource_quota;
@@ -123,6 +128,7 @@ struct PosixTcpOptions {
     keep_alive_timeout_ms = other.keep_alive_timeout_ms;
     expand_wildcard_addrs = other.expand_wildcard_addrs;
     allow_reuse_port = other.allow_reuse_port;
+    dscp = other.dscp;
   }
 };
 
@@ -156,6 +162,9 @@ grpc_error_handle grpc_set_socket_low_latency(int fd, int low_latency);
 // set SO_REUSEPORT
 grpc_error_handle grpc_set_socket_reuse_port(int fd, int reuse);
 
+/* Set Differentiated Services Code Point (DSCP) */
+grpc_error_handle grpc_set_socket_dscp(int fd, int dscp);
+
 // Configure the default values for TCP_USER_TIMEOUT
 void config_default_tcp_user_timeout(bool enable, int timeout, bool is_client);
 

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

@@ -76,6 +76,51 @@ void grpc_winsocket_shutdown(grpc_winsocket* winsocket) {
     return;
   }
   winsocket->shutdown_called = true;
+  bool register_shutdown = false;
+  // If there is already a scheduled read closure, run it immediately. This
+  // follows the same semantics applied to posix endpoint which also runs any
+  // already registered closure immediately in the event of a shutdown.
+  if (winsocket->read_info.closure && !winsocket->read_info.has_pending_iocp) {
+    winsocket->read_info.bytes_transferred = 0;
+    winsocket->read_info.wsa_error = WSA_OPERATION_ABORTED;
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, winsocket->read_info.closure,
+                            absl::OkStatus());
+    // Note that while the read_info.closure closure is run, it is not set to
+    // NULL here. This ensures that the socket cannot get deleted yet until any
+    // pending I/O operations are flushed by the thread executing
+    // grpc_iocp_work. We set read_info.closure_already_executed_at_shutdown to
+    // true so that when the pending read I/O operations are flushed, the
+    // associated closure is not executed in the grpc_socket_became_ready
+    // function.
+    winsocket->read_info.closure_already_executed_at_shutdown = true;
+    register_shutdown = true;
+  }
+
+  // If there is already a scheduled write closure, run it immediately. This
+  // follows the same semantics applied to posix endpoint which also runs any
+  // already registered closure immediately in the event of a shutdown.
+  if (winsocket->write_info.closure &&
+      !winsocket->write_info.has_pending_iocp) {
+    winsocket->write_info.bytes_transferred = 0;
+    winsocket->write_info.wsa_error = WSA_OPERATION_ABORTED;
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, winsocket->write_info.closure,
+                            absl::OkStatus());
+    // Note that while the write_info.closure closure is run, it is not set to
+    // NULL here. This ensures that the socket cannot get deleted yet until any
+    // pending I/O operations are flushed by the thread executing
+    // grpc_iocp_work. We set
+    // write_info.closure.closure_already_executed_at_shutdown to true so that
+    // when the pending write I/O operations are flushed, the associated closure
+    // is not executed in the grpc_socket_became_ready function.
+    winsocket->write_info.closure_already_executed_at_shutdown = true;
+    register_shutdown = true;
+  }
+
+  if (register_shutdown) {
+    // Instruct gRPC to avoid completing any shutdowns until this socket is
+    // cleaned up.
+    grpc_iocp_register_socket_shutdown_socket_locked(winsocket);
+  }
   gpr_mu_unlock(&winsocket->state_mu);
 
   status = WSAIoctl(winsocket->socket, SIO_GET_EXTENSION_FUNCTION_POINTER,
@@ -90,6 +135,8 @@ void grpc_winsocket_shutdown(grpc_winsocket* winsocket) {
             utf8_message);
     gpr_free(utf8_message);
   }
+  // Calling closesocket triggers invocation of any pending I/O operations with
+  // ABORTED status.
   closesocket(winsocket->socket);
 }
 
@@ -105,13 +152,20 @@ static bool check_destroyable(grpc_winsocket* winsocket) {
          winsocket->read_info.closure == NULL;
 }
 
+void grpc_winsocket_finish(grpc_winsocket* winsocket) {
+  grpc_iocp_finish_socket_shutdown(winsocket);
+  destroy(winsocket);
+}
+
 void grpc_winsocket_destroy(grpc_winsocket* winsocket) {
   gpr_mu_lock(&winsocket->state_mu);
   GPR_ASSERT(!winsocket->destroy_called);
   winsocket->destroy_called = true;
   bool should_destroy = check_destroyable(winsocket);
   gpr_mu_unlock(&winsocket->state_mu);
-  if (should_destroy) destroy(winsocket);
+  if (should_destroy) {
+    grpc_winsocket_finish(winsocket);
+  }
 }
 
 // Calling notify_on_read or write means either of two things:
@@ -140,19 +194,19 @@ void grpc_socket_notify_on_read(grpc_winsocket* socket, grpc_closure* closure) {
   socket_notify_on_iocp(socket, closure, &socket->read_info);
 }
 
-void grpc_socket_become_ready(grpc_winsocket* socket,
+bool grpc_socket_become_ready(grpc_winsocket* socket,
                               grpc_winsocket_callback_info* info) {
   GPR_ASSERT(!info->has_pending_iocp);
-  gpr_mu_lock(&socket->state_mu);
   if (info->closure) {
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, info->closure, absl::OkStatus());
+    // Only run the closure once at shutdown.
+    if (!info->closure_already_executed_at_shutdown) {
+      grpc_core::ExecCtx::Run(DEBUG_LOCATION, info->closure, absl::OkStatus());
+    }
     info->closure = NULL;
   } else {
     info->has_pending_iocp = 1;
   }
-  bool should_destroy = check_destroyable(socket);
-  gpr_mu_unlock(&socket->state_mu);
-  if (should_destroy) destroy(socket);
+  return check_destroyable(socket);
 }
 
 static gpr_once g_probe_ipv6_once = GPR_ONCE_INIT;