grpc 1.49.0.pre1-x86_64-linux → 1.50.0.pre1-x86_64-linux

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

@@ -48,7 +48,6 @@
 #include "src/core/lib/iomgr/ev_poll_posix.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/wakeup_fd_posix.h"
-#include "src/core/lib/profiling/timers.h"
 
 #define GRPC_POLLSET_KICK_BROADCAST ((grpc_pollset_worker*)1)
 
@@ -769,14 +768,11 @@ static void kick_append_error(grpc_error_handle* composite,
 static grpc_error_handle pollset_kick_ext(grpc_pollset* p,
                                           grpc_pollset_worker* specific_worker,
                                           uint32_t flags) {
-  GPR_TIMER_SCOPE("pollset_kick_ext", 0);
   grpc_error_handle error = GRPC_ERROR_NONE;
-  GRPC_STATS_INC_POLLSET_KICK();
 
   /* pollset->mu already held */
   if (specific_worker != nullptr) {
     if (specific_worker == GRPC_POLLSET_KICK_BROADCAST) {
-      GPR_TIMER_SCOPE("pollset_kick_ext.broadcast", 0);
       GPR_ASSERT((flags & GRPC_POLLSET_REEVALUATE_POLLING_ON_WAKEUP) == 0);
       for (specific_worker = p->root_worker.next;
            specific_worker != &p->root_worker;
@@ -786,7 +782,6 @@ static grpc_error_handle pollset_kick_ext(grpc_pollset* p,
       }
       p->kicked_without_pollers = true;
     } else if (g_current_thread_worker != specific_worker) {
-      GPR_TIMER_MARK("different_thread_worker", 0);
       if ((flags & GRPC_POLLSET_REEVALUATE_POLLING_ON_WAKEUP) != 0) {
         specific_worker->reevaluate_polling_on_wakeup = true;
       }
@@ -794,7 +789,6 @@ static grpc_error_handle pollset_kick_ext(grpc_pollset* p,
       kick_append_error(&error,
                         grpc_wakeup_fd_wakeup(&specific_worker->wakeup_fd->fd));
     } else if ((flags & GRPC_POLLSET_CAN_KICK_SELF) != 0) {
-      GPR_TIMER_MARK("kick_yoself", 0);
       if ((flags & GRPC_POLLSET_REEVALUATE_POLLING_ON_WAKEUP) != 0) {
         specific_worker->reevaluate_polling_on_wakeup = true;
       }
@@ -804,11 +798,9 @@ static grpc_error_handle pollset_kick_ext(grpc_pollset* p,
     }
   } else if (g_current_thread_poller != p) {
     GPR_ASSERT((flags & GRPC_POLLSET_REEVALUATE_POLLING_ON_WAKEUP) == 0);
-    GPR_TIMER_MARK("kick_anonymous", 0);
     specific_worker = pop_front_worker(p);
     if (specific_worker != nullptr) {
       if (g_current_thread_worker == specific_worker) {
-        GPR_TIMER_MARK("kick_anonymous_not_self", 0);
         push_back_worker(p, specific_worker);
         specific_worker = pop_front_worker(p);
         if ((flags & GRPC_POLLSET_CAN_KICK_SELF) == 0 &&
@@ -818,13 +810,11 @@ static grpc_error_handle pollset_kick_ext(grpc_pollset* p,
         }
       }
       if (specific_worker != nullptr) {
-        GPR_TIMER_MARK("finally_kick", 0);
         push_back_worker(p, specific_worker);
         kick_append_error(
             &error, grpc_wakeup_fd_wakeup(&specific_worker->wakeup_fd->fd));
       }
     } else {
-      GPR_TIMER_MARK("kicked_no_pollers", 0);
       p->kicked_without_pollers = true;
     }
   }
@@ -914,7 +904,6 @@ static void work_combine_error(grpc_error_handle* composite,
 static grpc_error_handle pollset_work(grpc_pollset* pollset,
                                       grpc_pollset_worker** worker_hdl,
                                       grpc_core::Timestamp deadline) {
-  GPR_TIMER_SCOPE("pollset_work", 0);
   grpc_pollset_worker worker;
   if (worker_hdl) *worker_hdl = &worker;
   grpc_error_handle error = GRPC_ERROR_NONE;
@@ -948,7 +937,6 @@ static grpc_error_handle pollset_work(grpc_pollset* pollset,
   worker.kicked_specifically = 0;
   /* If we're shutting down then we don't execute any extended work */
   if (pollset->shutting_down) {
-    GPR_TIMER_MARK("pollset_work.shutting_down", 0);
     goto done;
   }
   /* Start polling, and keep doing so while we're being asked to
@@ -959,13 +947,12 @@ static grpc_error_handle pollset_work(grpc_pollset* pollset,
   while (keep_polling) {
     keep_polling = 0;
     if (!pollset->kicked_without_pollers ||
-        deadline <= grpc_core::ExecCtx::Get()->Now()) {
+        deadline <= grpc_core::Timestamp::Now()) {
       if (!added_worker) {
         push_front_worker(pollset, &worker);
         added_worker = 1;
         g_current_thread_worker = &worker;
       }
-      GPR_TIMER_SCOPE("maybe_work_and_unlock", 0);
 #define POLLOUT_CHECK (POLLOUT | POLLHUP | POLLERR)
 #define POLLIN_CHECK (POLLIN | POLLHUP | POLLERR)
 
@@ -1024,7 +1011,6 @@ static grpc_error_handle pollset_work(grpc_pollset* pollset,
       /* TODO(vpai): Consider first doing a 0 timeout poll here to avoid
          even going into the blocking annotation if possible */
       GRPC_SCHEDULING_START_BLOCKING_REGION;
-      GRPC_STATS_INC_SYSCALL_POLL();
       r = grpc_poll_function(pfds, pfd_count, timeout);
       GRPC_SCHEDULING_END_BLOCKING_REGION;
 
@@ -1090,7 +1076,6 @@ static grpc_error_handle pollset_work(grpc_pollset* pollset,
 
       locked = 0;
     } else {
-      GPR_TIMER_MARK("pollset_work.kicked_without_pollers", 0);
       pollset->kicked_without_pollers = 0;
     }
   /* Finished execution - start cleaning up.
@@ -1160,7 +1145,7 @@ static void pollset_shutdown(grpc_pollset* pollset, grpc_closure* closure) {
 static int poll_deadline_to_millis_timeout(grpc_core::Timestamp deadline) {
   if (deadline == grpc_core::Timestamp::InfFuture()) return -1;
   if (deadline.is_process_epoch()) return 0;
-  int64_t n = (deadline - grpc_core::ExecCtx::Get()->Now()).millis();
+  int64_t n = (deadline - grpc_core::Timestamp::Now()).millis();
   if (n < 0) return 0;
   if (n > INT_MAX) return -1;
   return static_cast<int>(n);

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

@@ -25,7 +25,6 @@
 
 #include "src/core/lib/iomgr/combiner.h"
 #include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/profiling/timers.h"
 
 static void exec_ctx_run(grpc_closure* closure) {
 #ifndef NDEBUG
@@ -60,7 +59,6 @@ ApplicationCallbackExecCtx::callback_exec_ctx_;
 
 bool ExecCtx::Flush() {
   bool did_something = false;
-  GPR_TIMER_SCOPE("grpc_exec_ctx_flush", 0);
   for (;;) {
     if (!grpc_closure_list_empty(closure_list_)) {
       grpc_closure* c = closure_list_.head;
@@ -79,14 +77,6 @@ bool ExecCtx::Flush() {
   return did_something;
 }
 
-Timestamp ExecCtx::Now() {
-  if (!now_is_valid_) {
-    now_ = Timestamp::FromTimespecRoundDown(gpr_now(GPR_CLOCK_MONOTONIC));
-    now_is_valid_ = true;
-  }
-  return now_;
-}
-
 void ExecCtx::Run(const DebugLocation& location, grpc_closure* closure,
                   grpc_error_handle error) {
   (void)location;

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

@@ -176,30 +176,14 @@ class ExecCtx {
     }
   }
 
-  /** Returns the stored current time relative to start if valid,
-   *  otherwise refreshes the stored time, sets it valid and returns the new
-   *  value.
-   */
-  Timestamp Now();
-
-  /** Invalidates the stored time value. A new time value will be set on calling
-   *  Now().
-   */
-  void InvalidateNow() { now_is_valid_ = false; }
-
-  /** To be used only by shutdown code in iomgr */
+  Timestamp Now() { return Timestamp::Now(); }
+  void InvalidateNow() { time_cache_.InvalidateCache(); }
   void SetNowIomgrShutdown() {
-    now_ = Timestamp::InfFuture();
-    now_is_valid_ = true;
-  }
-
-  /** To be used only for testing.
-   *  Sets the now value.
-   */
-  void TestOnlySetNow(Timestamp new_val) {
-    now_ = new_val;
-    now_is_valid_ = true;
+    // 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());
   }
+  void TestOnlySetNow(Timestamp now) { time_cache_.TestOnlySetNow(now); }
 
   /** Gets pointer to current exec_ctx. */
   static ExecCtx* Get() { return exec_ctx_; }
@@ -226,9 +210,7 @@ class ExecCtx {
 
   unsigned starting_cpu_ = std::numeric_limits<unsigned>::max();
 
-  bool now_is_valid_ = false;
-  Timestamp now_;
-
+  ScopedTimeCache time_cache_;
   static GPR_THREAD_LOCAL(ExecCtx*) exec_ctx_;
   ExecCtx* last_exec_ctx_ = Get();
 };
@@ -338,12 +320,6 @@ class ApplicationCallbackExecCtx {
     ctx->tail_ = functor;
   }
 
-  /** Global initialization for ApplicationCallbackExecCtx. Called by init. */
-  static void GlobalInit(void) {}
-
-  /** Global shutdown for ApplicationCallbackExecCtx. Called by init. */
-  static void GlobalShutdown(void) {}
-
   static bool Available() { return Get() != nullptr; }
 
  private:

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

@@ -48,7 +48,7 @@ static DWORD deadline_to_millis_timeout(grpc_core::Timestamp deadline) {
   if (deadline == grpc_core::Timestamp::InfFuture()) {
     return INFINITE;
   }
-  grpc_core::Timestamp now = grpc_core::ExecCtx::Get()->Now();
+  grpc_core::Timestamp now = grpc_core::Timestamp::Now();
   if (deadline < now) return 0;
   grpc_core::Duration timeout = deadline - now;
   if (timeout.millis() > std::numeric_limits<DWORD>::max()) return INFINITE;
@@ -63,7 +63,6 @@ grpc_iocp_work_status grpc_iocp_work(grpc_core::Timestamp deadline) {
   LPOVERLAPPED overlapped;
   grpc_winsocket* socket;
   grpc_winsocket_callback_info* info;
-  GRPC_STATS_INC_SYSCALL_POLL();
   success =
       GetQueuedCompletionStatus(g_iocp, &bytes, &completion_key, &overlapped,
                                 deadline_to_millis_timeout(deadline));

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

@@ -45,13 +45,6 @@ GPR_GLOBAL_CONFIG_DEFINE_BOOL(grpc_abort_on_leaks, false,
                               "A debugging aid to cause a call to abort() when "
                               "gRPC objects are leaked past grpc_shutdown()");
 
-GPR_GLOBAL_CONFIG_DEFINE_BOOL(
-    grpc_experimental_enable_tcp_frame_size_tuning, false,
-    "If set, enables TCP to use RPC size estimation made by higher layers. TCP "
-    "would not indicate completion of a read operation until a specified "
-    "number of bytes have been read over the socket. Buffers are also "
-    "allocated according to estimated RPC sizes.");
-
 static gpr_mu g_mu;
 static gpr_cv g_rcv;
 static int g_shutdown;
@@ -85,7 +78,12 @@ static size_t count_objects(void) {
   return n;
 }
 
-size_t grpc_iomgr_count_objects_for_testing(void) { return count_objects(); }
+size_t grpc_iomgr_count_objects_for_testing(void) {
+  gpr_mu_lock(&g_mu);
+  size_t ret = count_objects();
+  gpr_mu_unlock(&g_mu);
+  return ret;
+}
 
 static void dump_objects(const char* kind) {
   grpc_iomgr_object* obj;

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

@@ -21,5 +21,6 @@
 #include <grpc/support/port_platform.h>
 
 typedef struct grpc_pollset_set grpc_pollset_set;
+typedef struct grpc_pollset grpc_pollset;
 
 #endif  // GRPC_CORE_LIB_IOMGR_IOMGR_FWD_H

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

@@ -25,6 +25,7 @@
 #include <grpc/support/time.h>
 
 #include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/iomgr/iomgr_fwd.h"
 
 extern grpc_core::DebugOnlyTraceFlag grpc_trace_fd_refcount;
 
@@ -35,7 +36,6 @@ extern grpc_core::DebugOnlyTraceFlag grpc_trace_fd_refcount;
     - a completion queue might keep a pollset with an entry for each transport
       that is servicing a call that it's tracking */
 
-typedef struct grpc_pollset grpc_pollset;
 typedef struct grpc_pollset_worker grpc_pollset_worker;
 
 typedef struct grpc_pollset_vtable {

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

@@ -22,7 +22,6 @@
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/iomgr/iomgr_fwd.h"
-#include "src/core/lib/iomgr/pollset.h"
 
 /* A grpc_pollset_set is a set of pollsets that are interested in an
    action. Adding a pollset to a pollset_set automatically adds any

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

@@ -28,6 +28,7 @@
 #include <grpc/event_engine/event_engine.h>
 
 #include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/lib/iomgr/resolved_address.h"

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

@@ -21,6 +21,7 @@
 
 #include <stddef.h>
 
+#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 

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

@@ -35,6 +35,7 @@
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/gprpp/thd.h"
 #include "src/core/lib/iomgr/block_annotate.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/resolve_address.h"
@@ -184,6 +185,8 @@ DNSResolver::TaskHandle NativeDNSResolver::LookupSRV(
     grpc_pollset_set* /* interested_parties */,
     absl::string_view /* name_server */) {
   GetDefaultEventEngine()->Run([on_resolved] {
+    ApplicationCallbackExecCtx app_exec_ctx;
+    ExecCtx exec_ctx;
     on_resolved(absl::UnimplementedError(
         "The Native resolver does not support looking up SRV records"));
   });
@@ -197,6 +200,8 @@ DNSResolver::TaskHandle NativeDNSResolver::LookupTXT(
     absl::string_view /* name_server */) {
   // Not supported
   GetDefaultEventEngine()->Run([on_resolved] {
+    ApplicationCallbackExecCtx app_exec_ctx;
+    ExecCtx exec_ctx;
     on_resolved(absl::UnimplementedError(
         "The Native resolver does not support looking up TXT records"));
   });

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

@@ -39,6 +39,7 @@
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/gprpp/thd.h"
 #include "src/core/lib/iomgr/block_annotate.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/resolve_address.h"
@@ -168,6 +169,8 @@ DNSResolver::TaskHandle NativeDNSResolver::LookupSRV(
     grpc_pollset_set* /* interested_parties */,
     absl::string_view /* name_server */) {
   GetDefaultEventEngine()->Run([on_resolved] {
+    ApplicationCallbackExecCtx app_exec_ctx;
+    ExecCtx exec_ctx;
     on_resolved(absl::UnimplementedError(
         "The Native resolver does not support looking up SRV records"));
   });
@@ -181,6 +184,8 @@ DNSResolver::TaskHandle NativeDNSResolver::LookupTXT(
     absl::string_view /* name_server */) {
   // Not supported
   GetDefaultEventEngine()->Run([on_resolved] {
+    ApplicationCallbackExecCtx app_exec_ctx;
+    ExecCtx exec_ctx;
     on_resolved(absl::UnimplementedError(
         "The Native resolver does not support looking up TXT records"));
   });

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

@@ -23,6 +23,8 @@
 #ifdef GRPC_POSIX_SOCKET_UTILS_COMMON
 
 #include "src/core/lib/iomgr/socket_utils.h"
+// sys/types.h must precede netinet/tcp.h for compatibility.
+#include <sys/types.h>
 #ifdef GRPC_LINUX_TCP_H
 #include <linux/tcp.h>
 #else
@@ -31,7 +33,6 @@
 #include <stdio.h>
 #include <string.h>
 #include <sys/socket.h>
-#include <sys/types.h>
 #include <unistd.h>
 
 #include <string>

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

@@ -43,12 +43,12 @@
 
 #include <string>
 
+#include <grpc/event_engine/endpoint_config.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
-#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 
@@ -298,10 +298,9 @@ void config_default_tcp_user_timeout(bool enable, int timeout, bool is_client) {
 
 /* Set TCP_USER_TIMEOUT */
 grpc_error_handle grpc_set_socket_tcp_user_timeout(
-    int fd, const grpc_channel_args* channel_args, bool is_client) {
+    int fd, const grpc_core::PosixTcpOptions& options, bool is_client) {
   // Use conditionally-important parameter to avoid warning
   (void)fd;
-  (void)channel_args;
   (void)is_client;
   extern grpc_core::TraceFlag grpc_tcp_trace;
   if (g_socket_supports_tcp_user_timeout.load() >= 0) {
@@ -314,29 +313,13 @@ grpc_error_handle grpc_set_socket_tcp_user_timeout(
       enable = g_default_server_tcp_user_timeout_enabled;
       timeout = g_default_server_tcp_user_timeout_ms;
     }
-    if (channel_args) {
-      for (unsigned int i = 0; i < channel_args->num_args; i++) {
-        if (0 ==
-            strcmp(channel_args->args[i].key, GRPC_ARG_KEEPALIVE_TIME_MS)) {
-          const int value = grpc_channel_arg_get_integer(
-              &channel_args->args[i], grpc_integer_options{0, 1, INT_MAX});
-          /* Continue using default if value is 0 */
-          if (value == 0) {
-            continue;
-          }
-          /* Disable if value is INT_MAX */
-          enable = value != INT_MAX;
-        } else if (0 == strcmp(channel_args->args[i].key,
-                               GRPC_ARG_KEEPALIVE_TIMEOUT_MS)) {
-          const int value = grpc_channel_arg_get_integer(
-              &channel_args->args[i], grpc_integer_options{0, 1, INT_MAX});
-          /* Continue using default if value is 0 */
-          if (value == 0) {
-            continue;
-          }
-          timeout = value;
-        }
-      }
+    int value = options.keep_alive_time_ms;
+    if (value > 0) {
+      enable = value != INT_MAX;
+    }
+    value = options.keep_alive_timeout_ms;
+    if (value > 0) {
+      timeout = value;
     }
     if (enable) {
       int newval;
@@ -398,16 +381,11 @@ grpc_error_handle grpc_set_socket_with_mutator(int fd, grpc_fd_usage usage,
 }
 
 grpc_error_handle grpc_apply_socket_mutator_in_args(
-    int fd, grpc_fd_usage usage, const grpc_channel_args* args) {
-  const grpc_arg* socket_mutator_arg =
-      grpc_channel_args_find(args, GRPC_ARG_SOCKET_MUTATOR);
-  if (socket_mutator_arg == nullptr) {
+    int fd, grpc_fd_usage usage, const grpc_core::PosixTcpOptions& options) {
+  if (options.socket_mutator == nullptr) {
     return GRPC_ERROR_NONE;
   }
-  GPR_DEBUG_ASSERT(socket_mutator_arg->type == GRPC_ARG_POINTER);
-  grpc_socket_mutator* mutator =
-      static_cast<grpc_socket_mutator*>(socket_mutator_arg->value.pointer.p);
-  return grpc_set_socket_with_mutator(fd, usage, mutator);
+  return grpc_set_socket_with_mutator(fd, usage, options.socket_mutator);
 }
 
 static gpr_once g_probe_ipv6_once = GPR_ONCE_INIT;

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

@@ -18,18 +18,100 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "absl/types/optional.h"
+
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_POSIX_SOCKETUTILS
-
 #include <fcntl.h>
 #include <sys/socket.h>
 #include <unistd.h>
 
+#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/socket_utils_posix.h"
+#endif
+
+#ifdef GRPC_POSIX_SOCKET_TCP
+
+#include "src/core/lib/event_engine/channel_args_endpoint_config.h"
+#include "src/core/lib/iomgr/socket_utils_posix.h"
+
+using ::grpc_event_engine::experimental::EndpointConfig;
+
+using ::grpc_core::PosixTcpOptions;
+
+namespace {
+
+int AdjustValue(int default_value, int min_value, int max_value,
+                absl::optional<int> actual_value) {
+  if (!actual_value.has_value() || *actual_value < min_value ||
+      *actual_value > max_value) {
+    return default_value;
+  }
+  return *actual_value;
+}
+}  // namespace
+
+PosixTcpOptions TcpOptionsFromEndpointConfig(const EndpointConfig& config) {
+  void* value;
+  PosixTcpOptions options;
+  options.tcp_read_chunk_size = AdjustValue(
+      PosixTcpOptions::kDefaultReadChunkSize, 1, PosixTcpOptions::kMaxChunkSize,
+      config.GetInt(GRPC_ARG_TCP_READ_CHUNK_SIZE));
+  options.tcp_min_read_chunk_size =
+      AdjustValue(PosixTcpOptions::kDefaultMinReadChunksize, 1,
+                  PosixTcpOptions::kMaxChunkSize,
+                  config.GetInt(GRPC_ARG_TCP_MIN_READ_CHUNK_SIZE));
+  options.tcp_max_read_chunk_size =
+      AdjustValue(PosixTcpOptions::kDefaultMaxReadChunksize, 1,
+                  PosixTcpOptions::kMaxChunkSize,
+                  config.GetInt(GRPC_ARG_TCP_MAX_READ_CHUNK_SIZE));
+  options.tcp_tx_zerocopy_send_bytes_threshold =
+      AdjustValue(PosixTcpOptions::kDefaultSendBytesThreshold, 0, INT_MAX,
+                  config.GetInt(GRPC_ARG_TCP_TX_ZEROCOPY_SEND_BYTES_THRESHOLD));
+  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_tx_zero_copy_enabled =
+      (AdjustValue(PosixTcpOptions::kZerocpTxEnabledDefault, 0, 1,
+                   config.GetInt(GRPC_ARG_TCP_TX_ZEROCOPY_ENABLED)) != 0);
+  options.keep_alive_time_ms =
+      AdjustValue(0, 1, INT_MAX, config.GetInt(GRPC_ARG_KEEPALIVE_TIME_MS));
+  options.keep_alive_timeout_ms =
+      AdjustValue(0, 1, INT_MAX, config.GetInt(GRPC_ARG_KEEPALIVE_TIMEOUT_MS));
+  options.expand_wildcard_addrs =
+      (AdjustValue(0, 1, INT_MAX,
+                   config.GetInt(GRPC_ARG_EXPAND_WILDCARD_ADDRS)) != 0);
+  options.allow_reuse_port =
+      (AdjustValue(0, 1, INT_MAX, config.GetInt(GRPC_ARG_ALLOW_REUSEPORT)) !=
+       0);
+
+  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;
+  }
+  options.tcp_read_chunk_size = grpc_core::Clamp(
+      options.tcp_read_chunk_size, options.tcp_min_read_chunk_size,
+      options.tcp_max_read_chunk_size);
+
+  value = config.GetVoidPointer(GRPC_ARG_RESOURCE_QUOTA);
+  if (value != nullptr) {
+    options.resource_quota =
+        reinterpret_cast<grpc_core::ResourceQuota*>(value)->Ref();
+  }
+  value = config.GetVoidPointer(GRPC_ARG_SOCKET_MUTATOR);
+  if (value != nullptr) {
+    options.socket_mutator =
+        grpc_socket_mutator_ref(static_cast<grpc_socket_mutator*>(value));
+  }
+  return options;
+}
+
+#endif /* GRPC_POSIX_SOCKET_TCP */
+
+#ifdef GRPC_POSIX_SOCKETUTILS
 
 int grpc_accept4(int sockfd, grpc_resolved_address* resolved_addr, int nonblock,
                  int cloexec) {