grpc 1.81.1 → 1.85.0

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

@@ -214,7 +214,7 @@ void TracedBufferList::AddNewEntry(int32_t seq_no, int fd, void* arg) {
                                &(new_elem->ts_.info));
   }
   new_elem->last_timestamp_ = new_elem->ts_.sendmsg_time.time;
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   if (!head_) {
     head_ = tail_ = new_elem;
   } else {
@@ -226,7 +226,7 @@ void TracedBufferList::AddNewEntry(int32_t seq_no, int fd, void* arg) {
 void TracedBufferList::ProcessTimestamp(struct sock_extended_err* serr,
                                         struct cmsghdr* opt_stats,
                                         struct scm_timestamping* tss) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   TracedBuffer* elem = head_;
   TracedBuffer* prev = nullptr;
   while (elem != nullptr) {
@@ -293,7 +293,7 @@ void TracedBufferList::ProcessTimestamp(struct sock_extended_err* serr,
 }
 
 void TracedBufferList::Shutdown(void* remaining, absl::Status shutdown_err) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   while (head_) {
     TracedBuffer* elem = head_;
     g_timestamps_callback(elem->arg_, &(elem->ts_), shutdown_err);

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

@@ -64,7 +64,7 @@ struct ConnectionMetrics {
   std::optional<uint32_t> congestion_window;
   // Slow start threshold in packets.
   std::optional<uint32_t> snd_ssthresh;
-  // Maximum degree of reordering (i.e., maximum number of packets reodered)
+  // Maximum degree of reordering (i.e., maximum number of packets reordered)
   // on the connection.
   std::optional<uint32_t> reordering;
   // Represents the number of recurring retransmissions of the first sequence
@@ -123,7 +123,7 @@ class TracedBufferList {
                         struct scm_timestamping* tss);
   // The Size() operation is slow and is used only in tests.
   int Size() {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     int size = 0;
     TracedBuffer* curr = head_;
     while (curr) {

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

@@ -75,9 +75,7 @@ void CFStreamHandle::ReadCallback(CFReadStreamRef stream,
       break;
     case kCFStreamEventErrorOccurred:
       stream_error = CFReadStreamCopyError(stream);
-      error = grpc_error_set_int(
-          GRPC_ERROR_CREATE_FROM_CFERROR(stream_error, "read error"),
-          grpc_core::StatusIntProperty::kRpcStatus, GRPC_STATUS_UNAVAILABLE);
+      error = GRPC_ERROR_CREATE_FROM_CFERROR(stream_error, "read error");
       CFRelease(stream_error);
       handle->open_event_.SetShutdown(error);
       handle->write_event_.SetShutdown(error);
@@ -107,9 +105,7 @@ void CFStreamHandle::WriteCallback(CFWriteStreamRef stream,
       break;
     case kCFStreamEventErrorOccurred:
       stream_error = CFWriteStreamCopyError(stream);
-      error = grpc_error_set_int(
-          GRPC_ERROR_CREATE_FROM_CFERROR(stream_error, "write error"),
-          grpc_core::StatusIntProperty::kRpcStatus, GRPC_STATUS_UNAVAILABLE);
+      error = GRPC_ERROR_CREATE_FROM_CFERROR(stream_error, "write error");
       CFRelease(stream_error);
       handle->open_event_.SetShutdown(error);
       handle->write_event_.SetShutdown(error);

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

@@ -217,7 +217,6 @@ bool grpc_combiner_continue_exec_ctx() {
     cl->cb(cl->cb_arg, std::move(cl_err));
   } else {
     grpc_closure* c = lock->final_list.head;
-    CHECK_NE(c, nullptr);
     grpc_closure_list_init(&lock->final_list);
     int loops = 0;
     while (c != nullptr) {

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

@@ -101,11 +101,6 @@ static void CFStreamUnref(CFStreamEndpoint* ep) {
 static void CFStreamRef(CFStreamEndpoint* ep) { gpr_ref(&ep->refcount); }
 #endif
 
-static grpc_error_handle CFStreamAnnotateError(grpc_error_handle src_error) {
-  return grpc_error_set_int(src_error, grpc_core::StatusIntProperty::kRpcStatus,
-                            GRPC_STATUS_UNAVAILABLE);
-}
-
 static void CallReadCb(CFStreamEndpoint* ep, grpc_error_handle error) {
   if (GRPC_TRACE_FLAG_ENABLED(tcp) && ABSL_VLOG_IS_ON(2)) {
     VLOG(2) << "CFStream endpoint:" << ep << " call_read_cb " << ep->read_cb
@@ -156,8 +151,7 @@ static void ReadAction(void* arg, grpc_error_handle error) {
     grpc_slice_buffer_reset_and_unref(ep->read_slices);
     CFErrorRef stream_error = CFReadStreamCopyError(ep->read_stream);
     if (stream_error != nullptr) {
-      error = CFStreamAnnotateError(
-          GRPC_ERROR_CREATE_FROM_CFERROR(stream_error, "Read error"));
+      error = GRPC_ERROR_CREATE_FROM_CFERROR(stream_error, "Read error");
       CFRelease(stream_error);
     } else {
       error = GRPC_ERROR_CREATE("Read error");
@@ -166,7 +160,7 @@ static void ReadAction(void* arg, grpc_error_handle error) {
     EP_UNREF(ep, "read");
   } else if (read_size == 0) {
     grpc_slice_buffer_reset_and_unref(ep->read_slices);
-    CallReadCb(ep, CFStreamAnnotateError(GRPC_ERROR_CREATE("Socket closed")));
+    CallReadCb(ep, absl::UnavailableError("Socket closed"));
     EP_UNREF(ep, "read");
   } else {
     if (read_size < static_cast<CFIndex>(len)) {
@@ -194,8 +188,7 @@ static void WriteAction(void* arg, grpc_error_handle error) {
     grpc_slice_buffer_reset_and_unref(ep->write_slices);
     CFErrorRef stream_error = CFWriteStreamCopyError(ep->write_stream);
     if (stream_error != nullptr) {
-      error = CFStreamAnnotateError(
-          GRPC_ERROR_CREATE_FROM_CFERROR(stream_error, "Write failed"));
+      error = GRPC_ERROR_CREATE_FROM_CFERROR(stream_error, "Write failed");
       CFRelease(stream_error);
     } else {
       error = GRPC_ERROR_CREATE("write failed.");

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

@@ -95,13 +95,9 @@ std::string WSAErrorToShortDescription(int err) {
 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 status = StatusCreate(
-      absl::StatusCode::kUnavailable,
+  absl::Status status = absl::UnavailableError(
       absl::StrCat(call_name, ": ", WSAErrorToShortDescription(err), " (",
-                   utf8_message, " -- ", err, ")"),
-      location, {});
-  StatusSetInt(&status, grpc_core::StatusIntProperty::kRpcStatus,
-               GRPC_STATUS_UNAVAILABLE);
+                   utf8_message, " -- ", err, ")"));
   gpr_free(utf8_message);
   return status;
 }
@@ -110,11 +106,6 @@ 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) {
-  if (!grpc_core::IsErrorFlattenEnabled() && src.ok()) {
-    src = absl::UnknownError("");
-    StatusSetInt(&src, grpc_core::StatusIntProperty::kRpcStatus,
-                 GRPC_STATUS_OK);
-  }
   grpc_core::StatusSetInt(&src, which, value);
   return src;
 }
@@ -125,79 +116,14 @@ bool grpc_error_get_int(grpc_error_handle error,
   if (value.has_value()) {
     *p = *value;
     return true;
-  } else {
-    // TODO(veblush): Remove this once absl::Status migration is done
-    if (!grpc_core::IsErrorFlattenEnabled() &&
-        which == grpc_core::StatusIntProperty::kRpcStatus) {
-      switch (error.code()) {
-        case absl::StatusCode::kOk:
-          *p = GRPC_STATUS_OK;
-          return true;
-        case absl::StatusCode::kResourceExhausted:
-          *p = GRPC_STATUS_RESOURCE_EXHAUSTED;
-          return true;
-        case absl::StatusCode::kCancelled:
-          *p = GRPC_STATUS_CANCELLED;
-          return true;
-        default:
-          break;
-      }
-    }
-    return false;
-  }
-}
-
-grpc_error_handle grpc_error_set_str(grpc_error_handle src,
-                                     grpc_core::StatusStrProperty which,
-                                     absl::string_view str) {
-  if (!grpc_core::IsErrorFlattenEnabled() && src.ok()) {
-    src = absl::UnknownError("");
-    StatusSetInt(&src, grpc_core::StatusIntProperty::kRpcStatus,
-                 GRPC_STATUS_OK);
-  }
-  grpc_core::StatusSetStr(&src, which, str);
-  return src;
-}
-
-bool grpc_error_get_str(grpc_error_handle error,
-                        grpc_core::StatusStrProperty which, std::string* s) {
-  std::optional<std::string> value = grpc_core::StatusGetStr(error, which);
-  if (value.has_value()) {
-    *s = std::move(*value);
-    return true;
-  } else {
-    // TODO(veblush): Remove this once absl::Status migration is done
-    if (!grpc_core::IsErrorFlattenEnabled() &&
-        which == grpc_core::StatusStrProperty::kGrpcMessage) {
-      switch (error.code()) {
-        case absl::StatusCode::kOk:
-          *s = "";
-          return true;
-        case absl::StatusCode::kCancelled:
-          *s = "CANCELLED";
-          return true;
-        default:
-          break;
-      }
-    }
-    return false;
   }
+  return false;
 }
 
 grpc_error_handle grpc_error_add_child(grpc_error_handle src,
                                        grpc_error_handle child) {
-  if (grpc_core::IsErrorFlattenEnabled()) {
-    grpc_core::StatusAddChild(&src, child);
-    return src;
-  }
-  if (src.ok()) {
-    return child;
-  } else {
-    if (!child.ok()) {
-      grpc_core::StatusAddChild(&src, child);
-    }
-    return src;
-  }
+  grpc_core::StatusAddChild(&src, child);
+  return src;
 }
 
 bool grpc_log_error(const char* what, grpc_error_handle error, const char* file,

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

@@ -19,6 +19,14 @@
 #ifndef GRPC_SRC_CORE_LIB_IOMGR_ERROR_H
 #define GRPC_SRC_CORE_LIB_IOMGR_ERROR_H
 
+///////////////////////////////////////////////////////////////////////////////
+//
+//                ALL APIs IN THIS FILE ARE DEPRECATED!
+//
+//         Callers should instead use absl::Status APIs directly.
+//
+///////////////////////////////////////////////////////////////////////////////
+
 #include <grpc/slice.h>
 #include <grpc/status.h>
 #include <grpc/support/port_platform.h>
@@ -94,12 +102,6 @@ grpc_error_handle grpc_error_set_int(grpc_error_handle src,
 /// 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);
-/// 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);
 
 /// Add a child error: an error that is believed to have contributed to this
 /// error occurring. Allows root causing high level errors from lower level

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

@@ -46,7 +46,6 @@ grpc_error_handle grpc_error_create_from_cferror(const char* file, int line,
       absl::StrFormat("%s (error domain:%s, code:%ld, description:%s)",
                       custom_desc, buf_domain, code, buf_desc);
   CFRelease(desc);
-  return StatusCreate(absl::StatusCode::kUnknown, error_msg,
-                      grpc_core::DebugLocation(file, line), {});
+  return absl::UnavailableError(error_msg);
 }
 #endif  // GRPC_CFSTREAM

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

@@ -109,7 +109,7 @@ static void grpc_apple_register_read_stream_run_loop(
     CFReadStreamRef read_stream, dispatch_queue_t /*dispatch_queue*/) {
   GRPC_TRACE_VLOG(apple_polling, 2)
       << "(polling) Register read stream: " << read_stream;
-  grpc_core::MutexLock lock(&gGlobalRunLoopContext->mu);
+  grpc_core::MutexLock lock(gGlobalRunLoopContext->mu);
   CFReadStreamScheduleWithRunLoop(read_stream, gGlobalRunLoopContext->run_loop,
                                   kCFRunLoopDefaultMode);
   gGlobalRunLoopContext->input_source_registered = true;
@@ -123,7 +123,7 @@ static void grpc_apple_register_write_stream_run_loop(
     CFWriteStreamRef write_stream, dispatch_queue_t /*dispatch_queue*/) {
   GRPC_TRACE_VLOG(apple_polling, 2)
       << "(polling) Register write stream: " << write_stream;
-  grpc_core::MutexLock lock(&gGlobalRunLoopContext->mu);
+  grpc_core::MutexLock lock(gGlobalRunLoopContext->mu);
   CFWriteStreamScheduleWithRunLoop(
       write_stream, gGlobalRunLoopContext->run_loop, kCFRunLoopDefaultMode);
   gGlobalRunLoopContext->input_source_registered = true;
@@ -183,7 +183,7 @@ static void pollset_global_init(void) {
   grpc_apple_register_write_stream_impl =
       grpc_apple_register_write_stream_run_loop;
 
-  grpc_core::MutexLock lock(&gGlobalRunLoopContext->mu);
+  grpc_core::MutexLock lock(gGlobalRunLoopContext->mu);
   gGlobalRunLoopThread =
       new grpc_core::Thread("apple_ev", GlobalRunLoopFunc, nullptr);
   gGlobalRunLoopThread->Start();
@@ -193,7 +193,7 @@ static void pollset_global_init(void) {
 
 static void pollset_global_shutdown(void) {
   {
-    grpc_core::MutexLock lock(&gGlobalRunLoopContext->mu);
+    grpc_core::MutexLock lock(gGlobalRunLoopContext->mu);
     gGlobalRunLoopContext->is_shutdown = true;
     CFRunLoopStop(gGlobalRunLoopContext->run_loop);
   }

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

@@ -334,9 +334,7 @@ static void fork_fd_list_remove_grpc_fd(grpc_fd* fd) {
 
 static grpc_fd* fd_create(int fd, const char* name, bool track_err) {
   grpc_fd* new_fd = nullptr;
-  if (grpc_core::IsEventEngineForAllOtherEndpointsEnabled() &&
-      !grpc_event_engine::experimental::
-          EventEngineExperimentDisabledForPython()) {
+  if (grpc_core::IsEventEngineForAllOtherEndpointsEnabled()) {
     grpc_fd* new_fd = static_cast<grpc_fd*>(gpr_malloc(sizeof(grpc_fd)));
     new_fd->fd = fd;
     return new_fd;
@@ -418,9 +416,7 @@ static void fd_shutdown(grpc_fd* fd, grpc_error_handle why) {
 
 static void fd_orphan(grpc_fd* fd, grpc_closure* on_done, int* release_fd,
                       const char* reason) {
-  if (grpc_core::IsEventEngineForAllOtherEndpointsEnabled() &&
-      !grpc_event_engine::experimental::
-          EventEngineExperimentDisabledForPython()) {
+  if (grpc_core::IsEventEngineForAllOtherEndpointsEnabled()) {
     GRPC_CHECK_NE(release_fd, nullptr);
     GRPC_CHECK_EQ(on_done, nullptr);
     *release_fd = fd->fd;
@@ -672,7 +668,7 @@ static int poll_deadline_to_millis_timeout(grpc_core::Timestamp millis) {
 // - This function then processes up-to MAX_EPOLL_EVENTS_PER_ITERATION and
 //   updates the g_epoll_set.cursor
 
-// NOTE ON SYNCRHONIZATION: Similar to do_epoll_wait(), this function is only
+// NOTE ON SYNCHRONIZATION: Similar to do_epoll_wait(), this function is only
 // called by g_active_poller thread. So there is no need for synchronization
 // when accessing fields in g_epoll_set
 static grpc_error_handle process_epoll_events(grpc_pollset* /*pollset*/) {

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

@@ -379,9 +379,7 @@ static void unref_by(grpc_fd* fd, int n) {
 }
 
 static grpc_fd* fd_create(int fd, const char* name, bool track_err) {
-  if (grpc_core::IsEventEngineForAllOtherEndpointsEnabled() &&
-      !grpc_event_engine::experimental::
-          EventEngineExperimentDisabledForPython()) {
+  if (grpc_core::IsEventEngineForAllOtherEndpointsEnabled()) {
     GRPC_TRACE_LOG(event_engine, ERROR)
         << "Creating a wrapped EventEngine grpc_fd with fd:" << fd;
     grpc_fd* new_fd = static_cast<grpc_fd*>(gpr_malloc(sizeof(grpc_fd)));
@@ -480,9 +478,7 @@ static int fd_wrapped_fd(grpc_fd* fd) {
 
 static void fd_orphan(grpc_fd* fd, grpc_closure* on_done, int* release_fd,
                       const char* reason) {
-  if (grpc_core::IsEventEngineForAllOtherEndpointsEnabled() &&
-      !grpc_event_engine::experimental::
-          EventEngineExperimentDisabledForPython()) {
+  if (grpc_core::IsEventEngineForAllOtherEndpointsEnabled()) {
     GRPC_CHECK_NE(release_fd, nullptr);
     GRPC_CHECK_EQ(on_done, nullptr);
     *release_fd = fd->fd;
@@ -526,21 +522,17 @@ static void fd_unref(grpc_fd* fd) { unref_by(fd, 2); }
 static grpc_error_handle fd_shutdown_error(grpc_fd* fd) {
   if (!fd->shutdown) {
     return absl::OkStatus();
-  } else {
-    return grpc_error_set_int(
-        GRPC_ERROR_CREATE_REFERENCING("FD shutdown", &fd->shutdown_error, 1),
-        grpc_core::StatusIntProperty::kRpcStatus, GRPC_STATUS_UNAVAILABLE);
   }
+  absl::Status status = absl::UnavailableError("FD shutdown");
+  grpc_core::StatusAddChild(&status, fd->shutdown_error);
+  return status;
 }
 
 static void notify_on_locked(grpc_fd* fd, grpc_closure** st,
                              grpc_closure* closure) {
   if (fd->shutdown || gpr_atm_no_barrier_load(&fd->pollhup)) {
-    grpc_core::ExecCtx::Run(
-        DEBUG_LOCATION, closure,
-        grpc_error_set_int(GRPC_ERROR_CREATE("FD shutdown"),
-                           grpc_core::StatusIntProperty::kRpcStatus,
-                           GRPC_STATUS_UNAVAILABLE));
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure,
+                            absl::UnavailableError("FD shutdown"));
   } else if (*st == CLOSURE_NOT_READY) {
     // not ready ==> switch to a waiting state by setting the closure
     *st = closure;

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

@@ -49,7 +49,7 @@ void RunEventEngineClosure(grpc_closure* closure, grpc_error_handle error) {
 absl::AnyInvocable<void(absl::Status)> GrpcClosureToStatusCallback(
     grpc_closure* closure) {
   return [closure](absl::Status status) {
-    RunEventEngineClosure(closure, absl_status_to_grpc_error(status));
+    RunEventEngineClosure(closure, status);
   };
 }
 

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

@@ -75,7 +75,7 @@ class EventEngineEndpointWrapper {
   }
 
   int Fd() {
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(mu_);
     return fd_;
   }
 
@@ -212,7 +212,7 @@ class EventEngineEndpointWrapper {
         kShutdownBit + 1) {
       auto* supports_fd =
           QueryExtension<EndpointSupportsFdExtension>(endpoint_.get());
-      if (supports_fd != nullptr && fd_ > 0 && on_release_fd_) {
+      if (supports_fd != nullptr && fd_ >= 0 && on_release_fd_) {
         supports_fd->Shutdown(std::move(on_release_fd_));
       }
       OnShutdownInternal();
@@ -241,7 +241,7 @@ class EventEngineEndpointWrapper {
         Ref();
         if (shutdown_ref_.fetch_sub(1, std::memory_order_acq_rel) ==
             kShutdownBit + 1) {
-          if (supports_fd != nullptr && fd_ > 0 && on_release_fd_) {
+          if (supports_fd != nullptr && fd_ >= 0 && on_release_fd_) {
             supports_fd->Shutdown(std::move(on_release_fd_));
           }
           OnShutdownInternal();
@@ -264,7 +264,7 @@ class EventEngineEndpointWrapper {
  private:
   void OnShutdownInternal() {
     {
-      grpc_core::MutexLock lock(&mu_);
+      grpc_core::MutexLock lock(mu_);
       fd_ = -1;
     }
     endpoint_.reset();
@@ -464,8 +464,7 @@ void grpc_event_engine_endpoint_destroy_and_release_fd(
           if (release_fd.ok()) {
             *fd = *release_fd;
           }
-          RunEventEngineClosure(on_release_fd,
-                                absl_status_to_grpc_error(release_fd.status()));
+          RunEventEngineClosure(on_release_fd, release_fd.status());
         });
   }
   eeep->wrapper->Unref();

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

@@ -62,8 +62,7 @@ int64_t event_engine_tcp_client_connect(
         }
         GRPC_TRACE_LOG(event_engine, INFO)
             << "EventEngine::Connect Status: " << ep.status();
-        grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_connect,
-                                absl_status_to_grpc_error(conn_status));
+        grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_connect, conn_status);
       },
       CreateResolvedAddress(*addr), config,
       resource_quota != nullptr

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

@@ -24,8 +24,6 @@
 
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
-#include "src/core/lib/iomgr/resolve_address.h"
-#include "src/core/lib/iomgr/resolve_address_posix.h"
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/iomgr/tcp_posix.h"
 #include "src/core/lib/iomgr/tcp_server.h"
@@ -38,7 +36,6 @@ extern grpc_pollset_vtable grpc_posix_pollset_vtable;
 extern grpc_pollset_set_vtable grpc_posix_pollset_set_vtable;
 
 static void iomgr_platform_init(void) {
-  grpc_core::ResetDNSResolver(std::make_unique<grpc_core::NativeDNSResolver>());
   grpc_wakeup_fd_global_init();
   grpc_event_engine_init();
   grpc_tcp_posix_init();
@@ -50,7 +47,6 @@ static void iomgr_platform_shutdown(void) {
   grpc_tcp_posix_shutdown();
   grpc_event_engine_shutdown();
   grpc_wakeup_fd_global_destroy();
-  grpc_core::ResetDNSResolver(nullptr);  // delete the resolver
 }
 
 static void iomgr_platform_shutdown_background_closure(void) {

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

@@ -40,8 +40,6 @@
 #include "src/core/lib/iomgr/ev_apple.h"
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
-#include "src/core/lib/iomgr/resolve_address.h"
-#include "src/core/lib/iomgr/resolve_address_posix.h"
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/iomgr/tcp_posix.h"
 #include "src/core/lib/iomgr/tcp_server.h"
@@ -63,7 +61,6 @@ static void apple_iomgr_platform_flush(void) {}
 
 static void apple_iomgr_platform_shutdown(void) {
   grpc_pollset_global_shutdown();
-  grpc_core::ResetDNSResolver(nullptr);  // delete the resolver
 }
 
 static void apple_iomgr_platform_shutdown_background_closure(void) {}
@@ -180,7 +177,6 @@ void grpc_set_default_iomgr_platform() {
   }
   grpc_tcp_client_global_init();
   grpc_set_timer_impl(&grpc_generic_timer_vtable);
-  grpc_core::ResetDNSResolver(std::make_unique<grpc_core::NativeDNSResolver>());
 }
 
 bool grpc_iomgr_run_in_background() {

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

@@ -26,8 +26,6 @@
 #include "src/core/lib/iomgr/iocp_windows.h"
 #include "src/core/lib/iomgr/iomgr.h"
 #include "src/core/lib/iomgr/pollset_windows.h"
-#include "src/core/lib/iomgr/resolve_address.h"
-#include "src/core/lib/iomgr/resolve_address_windows.h"
 #include "src/core/lib/iomgr/sockaddr_windows.h"
 #include "src/core/lib/iomgr/socket_windows.h"
 #include "src/core/lib/iomgr/tcp_client.h"
@@ -63,7 +61,6 @@ static void iomgr_platform_init(void) {
   grpc_iocp_init();
   grpc_pollset_global_init();
   grpc_wsa_socket_flags_init();
-  grpc_core::ResetDNSResolver(std::make_unique<grpc_core::NativeDNSResolver>());
 }
 
 static void iomgr_platform_flush(void) { grpc_iocp_flush(); }
@@ -72,7 +69,6 @@ static void iomgr_platform_shutdown(void) {
   grpc_pollset_global_shutdown();
   grpc_iocp_shutdown();
   winsock_shutdown();
-  grpc_core::ResetDNSResolver(nullptr);  // delete the resolver
 }
 
 static void iomgr_platform_shutdown_background_closure(void) {}

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

@@ -23,7 +23,7 @@
 #include <grpc/support/port_platform.h>
 #include <grpc/support/sync.h>
 
-#include "src/core/lib/iomgr/resolve_address.h"
+#include "src/core/lib/iomgr/resolved_address.h"
 
 /// The virtual table of grpc_socket_factory
 struct grpc_socket_factory_vtable {

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

@@ -74,6 +74,9 @@ PosixTcpOptions TcpOptionsFromEndpointConfig(
       AdjustValue(PosixTcpOptions::kDefaultMaxReadChunksize, 1,
                   PosixTcpOptions::kMaxChunkSize,
                   config.GetInt(GRPC_ARG_TCP_MAX_READ_CHUNK_SIZE));
+  options.tcp_max_read_buffer_size =
+      AdjustValue(PosixTcpOptions::kMaxReadBufferSizeUnset, 1, INT_MAX,
+                  config.GetInt(GRPC_ARG_TCP_MAX_READ_BUFFER_SIZE));
   options.tcp_tx_zerocopy_send_bytes_threshold =
       AdjustValue(PosixTcpOptions::kDefaultSendBytesThreshold, 0, INT_MAX,
                   config.GetInt(GRPC_ARG_TCP_TX_ZEROCOPY_SEND_BYTES_THRESHOLD));

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

@@ -51,6 +51,7 @@ struct PosixTcpOptions {
   static constexpr int kDefaultMaxReadChunksize = 4 * 1024 * 1024;
   static constexpr int kZerocpTxEnabledDefault = 0;
   static constexpr int kMaxChunkSize = 32 * 1024 * 1024;
+  static constexpr int kMaxReadBufferSizeUnset = -1;
   static constexpr int kDefaultMaxSends = 4;
   static constexpr size_t kDefaultSendBytesThreshold = 16 * 1024;
   // Let the system decide the proper buffer size.
@@ -59,6 +60,7 @@ struct PosixTcpOptions {
   int tcp_read_chunk_size = kDefaultReadChunkSize;
   int tcp_min_read_chunk_size = kDefaultMinReadChunksize;
   int tcp_max_read_chunk_size = kDefaultMaxReadChunksize;
+  int tcp_max_read_buffer_size = kMaxReadBufferSizeUnset;
   int tcp_tx_zerocopy_send_bytes_threshold = kDefaultSendBytesThreshold;
   int tcp_tx_zerocopy_max_simultaneous_sends = kDefaultMaxSends;
   int tcp_receive_buffer_size = kReadBufferSizeUnset;
@@ -128,6 +130,7 @@ struct PosixTcpOptions {
     tcp_read_chunk_size = other.tcp_read_chunk_size;
     tcp_min_read_chunk_size = other.tcp_min_read_chunk_size;
     tcp_max_read_chunk_size = other.tcp_max_read_chunk_size;
+    tcp_max_read_buffer_size = other.tcp_max_read_buffer_size;
     tcp_tx_zerocopy_send_bytes_threshold =
         other.tcp_tx_zerocopy_send_bytes_threshold;
     tcp_tx_zerocopy_max_simultaneous_sends =

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

@@ -27,7 +27,6 @@
 #endif
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
-#include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/systemd_utils.h"
 

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

@@ -26,7 +26,7 @@
 
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/pollset_set.h"
-#include "src/core/lib/iomgr/resolve_address.h"
+#include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
 
 typedef struct grpc_tcp_client_vtable {

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

@@ -258,7 +258,7 @@ finish:
     int shard_number = ac->connection_handle % (*g_connection_shards).size();
     struct ConnectionShard* shard = &(*g_connection_shards)[shard_number];
     {
-      grpc_core::MutexLock lock(&shard->mu);
+      grpc_core::MutexLock lock(shard->mu);
       shard->pending_connections.erase(ac->connection_handle);
     }
   }
@@ -387,7 +387,7 @@ int64_t grpc_tcp_client_create_from_prepared_fd(
   int shard_number = connection_id % (*g_connection_shards).size();
   struct ConnectionShard* shard = &(*g_connection_shards)[shard_number];
   {
-    grpc_core::MutexLock lock(&shard->mu);
+    grpc_core::MutexLock lock(shard->mu);
     shard->pending_connections.insert_or_assign(connection_id, ac);
   }
 
@@ -434,7 +434,7 @@ static bool tcp_cancel_connect(int64_t connection_handle) {
   struct ConnectionShard* shard = &(*g_connection_shards)[shard_number];
   async_connect* ac = nullptr;
   {
-    grpc_core::MutexLock lock(&shard->mu);
+    grpc_core::MutexLock lock(shard->mu);
     auto it = shard->pending_connections.find(connection_handle);
     if (it != shard->pending_connections.end()) {
       ac = it->second;