grpc 1.54.3 → 1.55.0

data/src/core/lib/channel/connected_channel.cc

@@ -56,8 +56,8 @@
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/promise/context.h"
-#include "src/core/lib/promise/detail/basic_join.h"
 #include "src/core/lib/promise/detail/basic_seq.h"
+#include "src/core/lib/promise/detail/status.h"
 #include "src/core/lib/promise/for_each.h"
 #include "src/core/lib/promise/if.h"
 #include "src/core/lib/promise/latch.h"
@@ -69,7 +69,6 @@
 #include "src/core/lib/promise/promise.h"
 #include "src/core/lib/promise/race.h"
 #include "src/core/lib/promise/seq.h"
-#include "src/core/lib/promise/try_join.h"
 #include "src/core/lib/promise/try_seq.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice.h"
@@ -321,7 +320,8 @@ class ConnectedChannelStream : public Orphanable {
   }
 
   // Returns a promise that implements the receive message loop.
-  auto RecvMessages(PipeSender<MessageHandle>* incoming_messages);
+  auto RecvMessages(PipeSender<MessageHandle>* incoming_messages,
+                    bool cancel_on_error);
   // Returns a promise that implements the send message loop.
   auto SendMessages(PipeReceiver<MessageHandle>* outgoing_messages);
 
@@ -374,12 +374,12 @@ class ConnectedChannelStream : public Orphanable {
 };
 
 auto ConnectedChannelStream::RecvMessages(
-    PipeSender<MessageHandle>* incoming_messages) {
-  return Loop([self = InternalRef(),
+    PipeSender<MessageHandle>* incoming_messages, bool cancel_on_error) {
+  return Loop([self = InternalRef(), cancel_on_error,
                incoming_messages = std::move(*incoming_messages)]() mutable {
     return Seq(
         GetContext<BatchBuilder>()->ReceiveMessage(self->batch_target()),
-        [&incoming_messages](
+        [cancel_on_error, &incoming_messages](
             absl::StatusOr<absl::optional<MessageHandle>> status) mutable {
           bool has_message = status.ok() && status->has_value();
           auto publish_message = [&incoming_messages, &status]() {
@@ -405,7 +405,8 @@ auto ConnectedChannelStream::RecvMessages(
                          return Continue{};
                        });
           };
-          auto publish_close = [&status]() mutable {
+          auto publish_close = [cancel_on_error, &incoming_messages,
+                                &status]() mutable {
             if (grpc_call_trace.enabled()) {
               gpr_log(GPR_INFO,
                       "%s[connected] RecvMessage: reached end of stream with "
@@ -413,6 +414,9 @@ auto ConnectedChannelStream::RecvMessages(
                       Activity::current()->DebugTag().c_str(),
                       status.status().ToString().c_str());
             }
+            if (cancel_on_error && !status.ok()) {
+              incoming_messages.CloseWithError();
+            }
             return Immediate(LoopCtl<absl::Status>(status.status()));
           };
           return If(has_message, std::move(publish_message),
@@ -442,9 +446,13 @@ ArenaPromise<ServerMetadataHandle> MakeClientCallPromise(
   grpc_transport_init_stream(transport, stream->stream(),
                              stream->stream_refcount(), nullptr,
                              GetContext<Arena>());
-  grpc_transport_set_pops(transport, stream->stream(),
-                          GetContext<CallContext>()->polling_entity());
   auto* party = static_cast<Party*>(Activity::current());
+  party->Spawn(
+      "set_polling_entity", call_args.polling_entity->Wait(),
+      [transport,
+       stream = stream->InternalRef()](grpc_polling_entity polling_entity) {
+        grpc_transport_set_pops(transport, stream->stream(), &polling_entity);
+      });
   // Start a loop to send messages from client_to_server_messages to the
   // transport. When the pipe closes and the loop completes, send a trailing
   // metadata batch to close the stream.
@@ -523,14 +531,44 @@ ArenaPromise<ServerMetadataHandle> MakeClientCallPromise(
   // complete (or one fails).
   // Next: receive trailing metadata, and return that up the stack.
   auto recv_messages =
-      stream->RecvMessages(call_args.server_to_client_messages);
-  return Map(TrySeq(TryJoin(std::move(send_initial_metadata),
-                            std::move(recv_messages)),
-                    std::move(recv_trailing_metadata)),
-             [stream = std::move(stream)](ServerMetadataHandle result) {
-               stream->set_finished();
-               return result;
-             });
+      stream->RecvMessages(call_args.server_to_client_messages, false);
+  return Map(
+      [send_initial_metadata = std::move(send_initial_metadata),
+       recv_messages = std::move(recv_messages),
+       recv_trailing_metadata = std::move(recv_trailing_metadata),
+       done_send_initial_metadata = false, done_recv_messages = false,
+       done_recv_trailing_metadata =
+           false]() mutable -> Poll<ServerMetadataHandle> {
+        if (!done_send_initial_metadata) {
+          auto p = send_initial_metadata();
+          if (auto* r = p.value_if_ready()) {
+            done_send_initial_metadata = true;
+            if (!r->ok()) return StatusCast<ServerMetadataHandle>(*r);
+          }
+        }
+        if (!done_recv_messages) {
+          auto p = recv_messages();
+          if (auto* r = p.value_if_ready()) {
+            // NOTE: ignore errors here, they'll be collected in the
+            // recv_trailing_metadata.
+            done_recv_messages = true;
+          } else {
+            return Pending{};
+          }
+        }
+        if (!done_recv_trailing_metadata) {
+          auto p = recv_trailing_metadata();
+          if (auto* r = p.value_if_ready()) {
+            done_recv_trailing_metadata = true;
+            return std::move(*r);
+          }
+        }
+        return Pending{};
+      },
+      [stream = std::move(stream)](ServerMetadataHandle result) {
+        stream->set_finished();
+        return result;
+      });
 }
 #endif
 
@@ -547,9 +585,6 @@ ArenaPromise<ServerMetadataHandle> MakeServerCallPromise(
       transport, stream->stream(), stream->stream_refcount(),
       GetContext<CallContext>()->server_call_context()->server_stream_data(),
       GetContext<Arena>());
-  grpc_transport_set_pops(transport, stream->stream(),
-                          GetContext<CallContext>()->polling_entity());
-
   auto* party = static_cast<Party*>(Activity::current());
 
   // Arifacts we need for the lifetime of the call.
@@ -558,11 +593,19 @@ ArenaPromise<ServerMetadataHandle> MakeServerCallPromise(
     Pipe<MessageHandle> client_to_server;
     Pipe<ServerMetadataHandle> server_initial_metadata;
     Latch<ServerMetadataHandle> failure_latch;
+    Latch<grpc_polling_entity> polling_entity_latch;
     bool sent_initial_metadata = false;
     bool sent_trailing_metadata = false;
   };
   auto* call_data = GetContext<Arena>()->ManagedNew<CallData>();
 
+  party->Spawn(
+      "set_polling_entity", call_data->polling_entity_latch.Wait(),
+      [transport,
+       stream = stream->InternalRef()](grpc_polling_entity polling_entity) {
+        grpc_transport_set_pops(transport, stream->stream(), &polling_entity);
+      });
+
   auto server_to_client_empty =
       call_data->server_to_client.receiver.AwaitEmpty();
 
@@ -580,6 +623,7 @@ ArenaPromise<ServerMetadataHandle> MakeServerCallPromise(
                auto call_promise = next_promise_factory(CallArgs{
                    std::move(client_initial_metadata),
                    ClientInitialMetadataOutstandingToken::Empty(),
+                   &call_data->polling_entity_latch,
                    &call_data->server_initial_metadata.sender,
                    &call_data->client_to_server.receiver,
                    &call_data->server_to_client.sender,
@@ -680,7 +724,7 @@ ArenaPromise<ServerMetadataHandle> MakeServerCallPromise(
       "recv_messages",
       Race(
           Map(stream->WaitFinished(), [](Empty) { return absl::OkStatus(); }),
-          Map(stream->RecvMessages(&call_data->client_to_server.sender),
+          Map(stream->RecvMessages(&call_data->client_to_server.sender, true),
               [failure_latch = &call_data->failure_latch](absl::Status status) {
                 if (!status.ok() && !failure_latch->is_set()) {
                   failure_latch->Set(ServerMetadataFromStatus(status));
@@ -769,12 +813,23 @@ ArenaPromise<ServerMetadataHandle> MakeServerCallPromise(
   // (allowing the call code to decide on what signalling to give the
   // application).
 
-  return Map(Seq(std::move(recv_initial_metadata_then_run_promise),
-                 std::move(send_trailing_metadata)),
-             [stream = std::move(stream)](ServerMetadataHandle md) {
-               stream->set_finished();
-               return md;
-             });
+  struct CleanupPollingEntityLatch {
+    void operator()(Latch<grpc_polling_entity>* latch) {
+      if (!latch->is_set()) latch->Set(grpc_polling_entity());
+    }
+  };
+  auto cleanup_polling_entity_latch =
+      std::unique_ptr<Latch<grpc_polling_entity>, CleanupPollingEntityLatch>(
+          &call_data->polling_entity_latch);
+
+  return Map(
+      Seq(std::move(recv_initial_metadata_then_run_promise),
+          std::move(send_trailing_metadata)),
+      [cleanup_polling_entity_latch = std::move(cleanup_polling_entity_latch),
+       stream = std::move(stream)](ServerMetadataHandle md) {
+        stream->set_finished();
+        return md;
+      });
 }
 #endif
 

data/src/core/lib/channel/promise_based_filter.cc

@@ -16,8 +16,6 @@
 
 #include "src/core/lib/channel/promise_based_filter.h"
 
-#include <inttypes.h>
-
 #include <algorithm>
 #include <initializer_list>
 #include <memory>
@@ -245,10 +243,6 @@ void BaseCallData::CapturedBatch::CancelWith(grpc_error_handle error,
   auto* batch = std::exchange(batch_, nullptr);
   GPR_ASSERT(batch != nullptr);
   uintptr_t& refcnt = *RefCountField(batch);
-  gpr_log(GPR_DEBUG, "%sCancelWith: %p refs=%" PRIdPTR " err=%s [%s]",
-          releaser->call()->DebugTag().c_str(), batch, refcnt,
-          error.ToString().c_str(),
-          grpc_transport_stream_op_batch_string(batch, false).c_str());
   if (refcnt == 0) {
     // refcnt==0 ==> cancelled
     if (grpc_trace_channel.enabled()) {
@@ -1583,7 +1577,7 @@ void ClientCallData::StartPromise(Flusher* flusher) {
   promise_ = filter->MakeCallPromise(
       CallArgs{WrapMetadata(send_initial_metadata_batch_->payload
                                 ->send_initial_metadata.send_initial_metadata),
-               std::move(initial_metadata_outstanding_token_),
+               std::move(initial_metadata_outstanding_token_), nullptr,
                server_initial_metadata_pipe() == nullptr
                    ? nullptr
                    : &server_initial_metadata_pipe()->sender,
@@ -2373,7 +2367,7 @@ void ServerCallData::RecvInitialMetadataReady(grpc_error_handle error) {
   FakeActivity(this).Run([this, filter] {
     promise_ = filter->MakeCallPromise(
         CallArgs{WrapMetadata(recv_initial_metadata_),
-                 ClientInitialMetadataOutstandingToken::Empty(),
+                 ClientInitialMetadataOutstandingToken::Empty(), nullptr,
                  server_initial_metadata_pipe() == nullptr
                      ? nullptr
                      : &server_initial_metadata_pipe()->sender,

data/src/core/lib/debug/trace.cc

@@ -24,6 +24,7 @@
 
 #include <string>
 #include <type_traits>
+#include <utility>
 
 #include "absl/strings/string_view.h"
 
@@ -77,12 +78,17 @@ void TraceFlagList::Add(TraceFlag* flag) {
 
 void TraceFlagList::LogAllTracers() {
   gpr_log(GPR_DEBUG, "available tracers:");
-  TraceFlag* t;
-  for (t = root_tracer_; t != nullptr; t = t->next_tracer_) {
+  for (TraceFlag* t = root_tracer_; t != nullptr; t = t->next_tracer_) {
     gpr_log(GPR_DEBUG, "\t%s", t->name_);
   }
 }
 
+void TraceFlagList::SaveTo(std::map<std::string, bool>& values) {
+  for (TraceFlag* t = root_tracer_; t != nullptr; t = t->next_tracer_) {
+    values[t->name_] = t->enabled();
+  }
+}
+
 // Flags register themselves on the list during construction
 TraceFlag::TraceFlag(bool default_enabled, const char* name) : name_(name) {
   static_assert(std::is_trivially_destructible<TraceFlag>::value,
@@ -91,6 +97,14 @@ TraceFlag::TraceFlag(bool default_enabled, const char* name) : name_(name) {
   TraceFlagList::Add(this);
 }
 
+SavedTraceFlags::SavedTraceFlags() { TraceFlagList::SaveTo(values_); }
+
+void SavedTraceFlags::Restore() {
+  for (const auto& flag : values_) {
+    TraceFlagList::Set(flag.first.c_str(), flag.second);
+  }
+}
+
 }  // namespace grpc_core
 
 static void add(const char* beg, const char* end, char*** ss, size_t* ns) {
@@ -138,11 +152,6 @@ static void parse(const char* s) {
   gpr_free(strings);
 }
 
-void grpc_tracer_init(const char* env_var_name) {
-  (void)env_var_name;  // suppress unused variable error
-  grpc_tracer_init();
-}
-
 void grpc_tracer_init() {
   parse(std::string(grpc_core::ConfigVars::Get().Trace()).c_str());
 }

data/src/core/lib/debug/trace.h

@@ -22,10 +22,8 @@
 #include <grpc/support/port_platform.h>
 
 #include <atomic>
-
-// TODO(veblush): Remove this deprecated function once codes depending on this
-// function are updated in the internal repo.
-void grpc_tracer_init(const char* env_var_name);
+#include <map>
+#include <string>
 
 void grpc_tracer_init();
 void grpc_tracer_shutdown(void);
@@ -37,6 +35,7 @@ class TraceFlagList {
  public:
   static bool Set(const char* name, bool enabled);
   static void Add(TraceFlag* flag);
+  static void SaveTo(std::map<std::string, bool>& values);
 
  private:
   static void LogAllTracers();
@@ -101,6 +100,15 @@ class DebugOnlyTraceFlag {
 };
 #endif
 
+class SavedTraceFlags {
+ public:
+  SavedTraceFlags();
+  void Restore();
+
+ private:
+  std::map<std::string, bool> values_;
+};
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_DEBUG_TRACE_H

data/src/core/lib/event_engine/posix_engine/posix_engine.cc

@@ -41,7 +41,6 @@
 #include "src/core/lib/event_engine/posix.h"
 #include "src/core/lib/event_engine/posix_engine/tcp_socket_utils.h"
 #include "src/core/lib/event_engine/posix_engine/timer.h"
-#include "src/core/lib/event_engine/shim.h"
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
 #include "src/core/lib/event_engine/trace.h"
 #include "src/core/lib/event_engine/utils.h"
@@ -66,10 +65,6 @@ using namespace std::chrono_literals;
 namespace grpc_event_engine {
 namespace experimental {
 
-bool NeedPosixEngine() {
-  return UseEventEngineClient() || UseEventEngineListener();
-}
-
 #ifdef GRPC_POSIX_SOCKET_TCP
 
 void AsyncConnect::Start(EventEngine::Duration timeout) {
@@ -340,24 +335,20 @@ PosixEventEngine::PosixEventEngine(PosixEventPoller* poller)
     : connection_shards_(std::max(2 * gpr_cpu_num_cores(), 1u)),
       executor_(std::make_shared<ThreadPool>()),
       timer_manager_(executor_) {
-  if (NeedPosixEngine()) {
-    poller_manager_ = std::make_shared<PosixEnginePollerManager>(poller);
-  }
+  poller_manager_ = std::make_shared<PosixEnginePollerManager>(poller);
 }
 
 PosixEventEngine::PosixEventEngine()
     : connection_shards_(std::max(2 * gpr_cpu_num_cores(), 1u)),
       executor_(std::make_shared<ThreadPool>()),
       timer_manager_(executor_) {
-  if (NeedPosixEngine()) {
-    poller_manager_ = std::make_shared<PosixEnginePollerManager>(executor_);
-    // The threadpool must be instantiated after the poller otherwise, the
-    // process will deadlock when forking.
-    if (poller_manager_->Poller() != nullptr) {
-      executor_->Run([poller_manager = poller_manager_]() {
-        PollerWorkInternal(poller_manager);
-      });
-    }
+  poller_manager_ = std::make_shared<PosixEnginePollerManager>(executor_);
+  // The threadpool must be instantiated after the poller otherwise, the
+  // process will deadlock when forking.
+  if (poller_manager_->Poller() != nullptr) {
+    executor_->Run([poller_manager = poller_manager_]() {
+      PollerWorkInternal(poller_manager);
+    });
   }
 }
 
@@ -549,9 +540,6 @@ EventEngine::ConnectionHandle PosixEventEngine::Connect(
     OnConnectCallback on_connect, const ResolvedAddress& addr,
     const EndpointConfig& args, MemoryAllocator memory_allocator,
     Duration timeout) {
-  if (!NeedPosixEngine()) {
-    grpc_core::Crash("unimplemented");
-  }
 #ifdef GRPC_POSIX_SOCKET_TCP
   GPR_ASSERT(poller_manager_ != nullptr);
   PosixTcpOptions options = TcpOptionsFromEndpointConfig(args);
@@ -574,9 +562,6 @@ std::unique_ptr<PosixEndpointWithFdSupport>
 PosixEventEngine::CreatePosixEndpointFromFd(int fd,
                                             const EndpointConfig& config,
                                             MemoryAllocator memory_allocator) {
-  if (!NeedPosixEngine()) {
-    grpc_core::Crash("unimplemented");
-  }
 #ifdef GRPC_POSIX_SOCKET_TCP
   GPR_DEBUG_ASSERT(fd > 0);
   PosixEventPoller* poller = poller_manager_->Poller();
@@ -623,9 +608,6 @@ PosixEventEngine::CreatePosixListener(
     absl::AnyInvocable<void(absl::Status)> on_shutdown,
     const EndpointConfig& config,
     std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory) {
-  if (!NeedPosixEngine()) {
-    grpc_core::Crash("unimplemented");
-  }
 #ifdef GRPC_POSIX_SOCKET_TCP
   return std::make_unique<PosixEngineListener>(
       std::move(on_accept), std::move(on_shutdown), config,

data/src/core/lib/event_engine/posix_engine/posix_engine.h

@@ -196,7 +196,6 @@ class PosixEventEngine final : public PosixEventEngineWithFdSupport,
       const DNSResolver::ResolverOptions& options) override;
   void Run(Closure* closure) override;
   void Run(absl::AnyInvocable<void()> closure) override;
-  // Caution!! The timer implementation cannot create any fds. See #20418.
   TaskHandle RunAfter(Duration when, Closure* closure) override;
   TaskHandle RunAfter(Duration when,
                       absl::AnyInvocable<void()> closure) override;

data/src/core/lib/event_engine/posix_engine/posix_engine_listener.cc

@@ -23,9 +23,7 @@
 #include <sys/socket.h>  // IWYU pragma: keep
 #include <unistd.h>      // IWYU pragma: keep
 
-#include <atomic>
 #include <string>
-#include <tuple>
 #include <utility>
 
 #include "absl/functional/any_invocable.h"
@@ -43,7 +41,6 @@
 #include "src/core/lib/event_engine/posix_engine/tcp_socket_utils.h"
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
 #include "src/core/lib/gprpp/status_helper.h"
-#include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/socket_mutator.h"
 
 namespace grpc_event_engine {
@@ -139,32 +136,6 @@ void PosixEngineListenerImpl::AsyncConnectionAcceptor::NotifyOnAccept(
       switch (errno) {
         case EINTR:
           continue;
-        case EMFILE:
-          // When the process runs out of fds, accept4() returns EMFILE. When
-          // this happens, the connection is left in the accept queue until
-          // either a read event triggers the on_read callback, or time has
-          // passed and the accept should be re-tried regardless. This callback
-          // is not cancelled, so a spurious wakeup may occur even when there's
-          // nothing to accept. This is not a performant code path, but if an fd
-          // limit has been reached, the system is likely in an unhappy state
-          // regardless.
-          GRPC_LOG_EVERY_N_SEC(1, GPR_ERROR, "%s",
-                               "File descriptor limit reached. Retrying.");
-          handle_->NotifyOnRead(notify_on_accept_);
-          // Do not schedule another timer if one is already armed.
-          if (retry_timer_armed_.exchange(true)) return;
-          // Hold a ref while the retry timer is waiting, to prevent listener
-          // destruction and the races that would ensue.
-          Ref();
-          std::ignore =
-              engine_->RunAfter(grpc_core::Duration::Seconds(1), [this]() {
-                retry_timer_armed_.store(false);
-                if (!handle_->IsHandleShutdown()) {
-                  handle_->SetReadable();
-                }
-                Unref();
-              });
-          return;
         case EAGAIN:
         case ECONNABORTED:
           handle_->NotifyOnRead(notify_on_accept_);

data/src/core/lib/event_engine/posix_engine/posix_engine_listener.h

@@ -121,9 +121,6 @@ class PosixEngineListenerImpl
     ListenerSocketsContainer::ListenerSocket socket_;
     EventHandle* handle_;
     PosixEngineClosure* notify_on_accept_;
-    // Tracks the status of a backup timer to retry accept4 calls after file
-    // descriptor exhaustion.
-    std::atomic<bool> retry_timer_armed_{false};
   };
   class ListenerAsyncAcceptors : public ListenerSocketsContainer {
    public:

data/src/core/lib/event_engine/posix_engine/tcp_socket_utils.cc

@@ -125,7 +125,9 @@ absl::Status PrepareTcpClientSocket(PosixSocketWrapper sock,
   });
   GRPC_RETURN_IF_ERROR(sock.SetSocketNonBlocking(1));
   GRPC_RETURN_IF_ERROR(sock.SetSocketCloexec(1));
-
+  if (options.tcp_receive_buffer_size != options.kReadBufferSizeUnset) {
+    GRPC_RETURN_IF_ERROR(sock.SetSocketRcvBuf(options.tcp_receive_buffer_size));
+  }
   if (reinterpret_cast<const sockaddr*>(addr.address())->sa_family != AF_UNIX) {
     // If its not a unix socket address.
     GRPC_RETURN_IF_ERROR(sock.SetSocketLowLatency(1));
@@ -169,6 +171,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);

data/src/core/lib/event_engine/posix_engine/tcp_socket_utils.h

@@ -58,11 +58,14 @@ 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;
   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;

data/src/core/lib/event_engine/shim.cc

@@ -29,6 +29,8 @@ bool UseEventEngineClient() {
   return grpc_core::IsEventEngineClientEnabled();
 #elif defined(GPR_WINDOWS)
   return grpc_core::IsEventEngineClientEnabled();
+#elif defined(GRPC_IOS_EVENT_ENGINE_CLIENT)
+  return true;
 #else
   return false;
 #endif

data/src/core/lib/event_engine/trace.cc

@@ -16,6 +16,7 @@
 #include "src/core/lib/debug/trace.h"
 
 grpc_core::TraceFlag grpc_event_engine_trace(false, "event_engine");
+grpc_core::TraceFlag grpc_event_engine_dns_trace(false, "event_engine_dns");
 grpc_core::TraceFlag grpc_event_engine_endpoint_trace(false,
                                                       "event_engine_endpoint");
 grpc_core::TraceFlag grpc_event_engine_endpoint_data_trace(

data/src/core/lib/event_engine/trace.h

@@ -21,6 +21,7 @@
 #include "src/core/lib/debug/trace.h"
 
 extern grpc_core::TraceFlag grpc_event_engine_trace;
+extern grpc_core::TraceFlag grpc_event_engine_dns_trace;
 extern grpc_core::TraceFlag grpc_event_engine_endpoint_data_trace;
 extern grpc_core::TraceFlag grpc_event_engine_poller_trace;
 extern grpc_core::TraceFlag grpc_event_engine_endpoint_trace;
@@ -40,4 +41,9 @@ extern grpc_core::TraceFlag grpc_event_engine_endpoint_trace;
     gpr_log(GPR_DEBUG, "(event_engine poller) " format, __VA_ARGS__); \
   }
 
+#define GRPC_EVENT_ENGINE_DNS_TRACE(format, ...)                   \
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_dns_trace)) {      \
+    gpr_log(GPR_DEBUG, "(event_engine dns) " format, __VA_ARGS__); \
+  }
+
 #endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_TRACE_H

data/src/core/lib/experiments/experiments.cc

@@ -58,6 +58,8 @@ const char* const description_schedule_cancellation_over_write =
     "Allow cancellation op to be scheduled over a write";
 const char* const description_trace_record_callops =
     "Enables tracing of call batch initiation and completion.";
+const char* const description_event_engine_dns =
+    "If set, use EventEngine DNSResolver for client channel resolution";
 }  // namespace
 
 namespace grpc_core {
@@ -82,6 +84,7 @@ const ExperimentMetadata g_experiment_metadata[] = {
     {"schedule_cancellation_over_write",
      description_schedule_cancellation_over_write, false},
     {"trace_record_callops", description_trace_record_callops, false},
+    {"event_engine_dns", description_event_engine_dns, false},
 };
 
 }  // namespace grpc_core

data/src/core/lib/experiments/experiments.h

@@ -74,6 +74,7 @@ inline bool IsTransportSuppliesClientLatencyEnabled() { return false; }
 inline bool IsEventEngineListenerEnabled() { return false; }
 inline bool IsScheduleCancellationOverWriteEnabled() { return false; }
 inline bool IsTraceRecordCallopsEnabled() { return false; }
+inline bool IsEventEngineDnsEnabled() { return false; }
 #else
 #define GRPC_EXPERIMENT_IS_INCLUDED_TCP_FRAME_SIZE_TUNING
 inline bool IsTcpFrameSizeTuningEnabled() { return IsExperimentEnabled(0); }
@@ -115,8 +116,10 @@ inline bool IsScheduleCancellationOverWriteEnabled() {
 }
 #define GRPC_EXPERIMENT_IS_INCLUDED_TRACE_RECORD_CALLOPS
 inline bool IsTraceRecordCallopsEnabled() { return IsExperimentEnabled(14); }
+#define GRPC_EXPERIMENT_IS_INCLUDED_EVENT_ENGINE_DNS
+inline bool IsEventEngineDnsEnabled() { return IsExperimentEnabled(15); }
 
-constexpr const size_t kNumExperiments = 15;
+constexpr const size_t kNumExperiments = 16;
 extern const ExperimentMetadata g_experiment_metadata[kNumExperiments];
 
 #endif

data/src/core/lib/gpr/posix/time.cc

@@ -80,6 +80,11 @@ static gpr_timespec now_impl(gpr_clock_type clock_type) {
 #else
     clock_gettime(clockid_for_gpr_clock[clock_type], &now);
 #endif
+    if (clock_type == GPR_CLOCK_MONOTONIC) {
+      // Add 5 seconds arbitrarily: avoids weird conditions in gprpp/time.cc
+      // when there's a small number of seconds returned.
+      now.tv_sec += 5;
+    }
     return gpr_from_timespec(now, clock_type);
   }
 }

data/src/core/lib/gprpp/status_helper.cc

@@ -34,8 +34,8 @@
 #include "absl/time/clock.h"
 #include "google/protobuf/any.upb.h"
 #include "google/rpc/status.upb.h"
-#include "upb/arena.h"
-#include "upb/upb.h"
+#include "upb/base/string_view.h"
+#include "upb/mem/arena.h"
 #include "upb/upb.hpp"
 
 #include <grpc/support/log.h>

data/src/core/lib/gprpp/validation_errors.cc

@@ -42,8 +42,14 @@ bool ValidationErrors::FieldHasErrors() const {
   return field_errors_.find(absl::StrJoin(fields_, "")) != field_errors_.end();
 }
 
-absl::Status ValidationErrors::status(absl::string_view prefix) const {
+absl::Status ValidationErrors::status(absl::StatusCode code,
+                                      absl::string_view prefix) const {
   if (field_errors_.empty()) return absl::OkStatus();
+  return absl::Status(code, message(prefix));
+}
+
+std::string ValidationErrors::message(absl::string_view prefix) const {
+  if (field_errors_.empty()) return "";
   std::vector<std::string> errors;
   for (const auto& p : field_errors_) {
     if (p.second.size() > 1) {
@@ -54,8 +60,7 @@ absl::Status ValidationErrors::status(absl::string_view prefix) const {
           absl::StrCat("field:", p.first, " error:", p.second[0]));
     }
   }
-  return absl::InvalidArgumentError(
-      absl::StrCat(prefix, ": [", absl::StrJoin(errors, "; "), "]"));
+  return absl::StrCat(prefix, ": [", absl::StrJoin(errors, "; "), "]");
 }
 
 }  // namespace grpc_core