grpc 1.81.1 → 1.83.1

data/src/core/lib/compression/message_compress.cc

@@ -25,168 +25,203 @@
 #include <zconf.h>
 #include <zlib.h>
 
+#include <algorithm>
+#include <cstdint>
+#include <optional>
+
 #include "src/core/lib/slice/slice.h"
 #include "src/core/util/grpc_check.h"
+#include "src/core/util/status_helper.h"
 #include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
 
 #define OUTPUT_BLOCK_SIZE 1024
 
-static int zlib_body(z_stream* zs, grpc_slice_buffer* input,
-                     grpc_slice_buffer* output,
-                     int (*flate)(z_stream* zs, int flush)) {
+namespace grpc_core {
+namespace {
+
+absl::StatusOr<SliceBuffer> ZlibBody(z_stream* zs, const SliceBuffer& input,
+                                     int (*flate)(z_stream* zs, int flush),
+                                     std::optional<uint32_t> max_output_size) {
   int r = Z_STREAM_END;  // Do not fail on an empty input.
   int flush;
   size_t i;
-  grpc_slice outbuf = GRPC_SLICE_MALLOC(OUTPUT_BLOCK_SIZE);
+  uint32_t remaining_output_size = max_output_size.value_or(UINT32_MAX);
+  SliceBuffer output_sb;
   const uInt uint_max = ~uInt{0};
+  auto outbuf = MutableSlice::CreateUninitialized(
+      std::min<uint32_t>(remaining_output_size, OUTPUT_BLOCK_SIZE));
 
-  GRPC_CHECK(GRPC_SLICE_LENGTH(outbuf) <= uint_max);
-  zs->avail_out = static_cast<uInt> GRPC_SLICE_LENGTH(outbuf);
-  zs->next_out = GRPC_SLICE_START_PTR(outbuf);
+  GRPC_CHECK(outbuf.length() <= uint_max);
+  zs->avail_out = static_cast<uInt>(outbuf.length());
+  zs->next_out = const_cast<uint8_t*>(outbuf.begin());
   flush = Z_NO_FLUSH;
-  for (i = 0; i < input->count; i++) {
-    if (i == input->count - 1) flush = Z_FINISH;
-    GRPC_CHECK(GRPC_SLICE_LENGTH(input->slices[i]) <= uint_max);
-    zs->avail_in = static_cast<uInt> GRPC_SLICE_LENGTH(input->slices[i]);
-    zs->next_in = GRPC_SLICE_START_PTR(input->slices[i]);
+  for (i = 0; i < input.Count(); i++) {
+    if (i == input.Count() - 1) {
+      flush = Z_FINISH;
+    }
+    GRPC_CHECK(input[i].length() <= uint_max);
+    zs->avail_in = static_cast<uInt>(input[i].length());
+    zs->next_in = const_cast<uint8_t*>(input[i].begin());
     do {
       if (zs->avail_out == 0) {
-        grpc_slice_buffer_add_indexed(output, outbuf);
-        outbuf = GRPC_SLICE_MALLOC(OUTPUT_BLOCK_SIZE);
-        GRPC_CHECK(GRPC_SLICE_LENGTH(outbuf) <= uint_max);
-        zs->avail_out = static_cast<uInt> GRPC_SLICE_LENGTH(outbuf);
-        zs->next_out = GRPC_SLICE_START_PTR(outbuf);
+        if (max_output_size.has_value() && remaining_output_size == 0) {
+          VLOG(2) << "zlib: max provided output size exceeded";
+          return absl::ResourceExhaustedError(
+              "Decompressed message larger than max");
+        }
+        output_sb.AppendIndexed(Slice(std::move(outbuf)));
+        outbuf = MutableSlice::CreateUninitialized(
+            std::min<uint32_t>(remaining_output_size, OUTPUT_BLOCK_SIZE));
+        // Update remaining output size to reflect the size of the slice we just
+        // filled with compressed / decompressed data.
+        if (max_output_size.has_value()) {
+          remaining_output_size -= outbuf.length();
+        }
+        GRPC_CHECK(outbuf.length() <= uint_max);
+        zs->avail_out = static_cast<uInt>(outbuf.length());
+        zs->next_out = const_cast<uint8_t*>(outbuf.begin());
       }
       r = flate(zs, flush);
       if (r < 0 && r != Z_BUF_ERROR /* not fatal */) {
         VLOG(2) << "zlib error (" << r << ")";
-        goto error;
+        return absl::InternalError("Decompression failed due to zlib error");
       }
     } while (zs->avail_out == 0);
     if (zs->avail_in) {
       VLOG(2) << "zlib: not all input consumed";
-      goto error;
+      return absl::InternalError(
+          "Decompression failed due to not all input "
+          "consumed");
     }
   }
   if (r != Z_STREAM_END) {
     VLOG(2) << "zlib: Data error";
-    goto error;
+    return absl::InternalError("Decompression failed due to data error");
   }
 
-  GRPC_CHECK(outbuf.refcount);
-  outbuf.data.refcounted.length -= zs->avail_out;
-  grpc_slice_buffer_add_indexed(output, outbuf);
-
-  return 1;
-
-error:
-  grpc_core::CSliceUnref(outbuf);
-  return 0;
+  // TODO(vigneshbabu): Add a Truncate() method to the Slice type to avoid using
+  // the underlying C type here.
+  grpc_slice slice = outbuf.TakeCSlice();
+  if (slice.refcount) {
+    slice.data.refcounted.length -= zs->avail_out;
+  } else {
+    slice.data.inlined.length -= zs->avail_out;
+  }
+  output_sb.AppendIndexed(Slice(slice));
+  return output_sb;
 }
 
-static void* zalloc_gpr(void* /*opaque*/, unsigned int items,
-                        unsigned int size) {
+void* ZallocGpr(void* /*opaque*/, unsigned int items, unsigned int size) {
   return gpr_malloc(items * size);
 }
 
-static void zfree_gpr(void* /*opaque*/, void* address) { gpr_free(address); }
+void ZFreeGpr(void* /*opaque*/, void* address) { gpr_free(address); }
 
-static int zlib_compress(grpc_slice_buffer* input, grpc_slice_buffer* output,
-                         int gzip) {
+std::optional<SliceBuffer> ZlibCompress(const SliceBuffer& input, int gzip) {
   z_stream zs;
-  int r;
-  size_t i;
-  size_t count_before = output->count;
-  size_t length_before = output->length;
+  absl::StatusOr<SliceBuffer> compression_result;
   memset(&zs, 0, sizeof(zs));
-  zs.zalloc = zalloc_gpr;
-  zs.zfree = zfree_gpr;
-  r = deflateInit2(&zs, Z_DEFAULT_COMPRESSION, Z_DEFLATED, 15 | (gzip ? 16 : 0),
-                   8, Z_DEFAULT_STRATEGY);
+  zs.zalloc = ZallocGpr;
+  zs.zfree = ZFreeGpr;
+  bool r = deflateInit2(&zs, Z_DEFAULT_COMPRESSION, Z_DEFLATED,
+                        15 | (gzip ? 16 : 0), 8, Z_DEFAULT_STRATEGY);
   GRPC_CHECK(r == Z_OK);
-  r = zlib_body(&zs, input, output, deflate) && output->length < input->length;
-  if (!r) {
-    for (i = count_before; i < output->count; i++) {
-      grpc_core::CSliceUnref(output->slices[i]);
-    }
-    output->count = count_before;
-    output->length = length_before;
-  }
+  compression_result = ZlibBody(&zs, input, deflate, input.Length());
   deflateEnd(&zs);
-  return r;
+  if (compression_result.ok() &&
+      compression_result->Length() < input.Length()) {
+    return std::move(*compression_result);
+  }
+  return std::nullopt;
 }
 
-static int zlib_decompress(grpc_slice_buffer* input, grpc_slice_buffer* output,
-                           int gzip) {
+absl::StatusOr<SliceBuffer> ZlibDecompress(
+    const SliceBuffer& input, int gzip,
+    std::optional<uint32_t> max_output_size) {
   z_stream zs;
-  int r;
-  size_t i;
-  size_t count_before = output->count;
-  size_t length_before = output->length;
+  absl::StatusOr<SliceBuffer> decompression_result;
   memset(&zs, 0, sizeof(zs));
-  zs.zalloc = zalloc_gpr;
-  zs.zfree = zfree_gpr;
-  r = inflateInit2(&zs, 15 | (gzip ? 16 : 0));
+  zs.zalloc = ZallocGpr;
+  zs.zfree = ZFreeGpr;
+  bool r = inflateInit2(&zs, 15 | (gzip ? 16 : 0));
   GRPC_CHECK(r == Z_OK);
-  r = zlib_body(&zs, input, output, inflate);
-  if (!r) {
-    for (i = count_before; i < output->count; i++) {
-      grpc_core::CSliceUnref(output->slices[i]);
-    }
-    output->count = count_before;
-    output->length = length_before;
-  }
+  decompression_result = ZlibBody(&zs, input, inflate, max_output_size);
   inflateEnd(&zs);
-  return r;
+  return decompression_result;
 }
 
-static int copy(grpc_slice_buffer* input, grpc_slice_buffer* output) {
-  size_t i;
-  for (i = 0; i < input->count; i++) {
-    grpc_slice_buffer_add(output, grpc_core::CSliceRef(input->slices[i]));
-  }
-  return 1;
-}
+}  // namespace
 
-static int compress_inner(grpc_compression_algorithm algorithm,
-                          grpc_slice_buffer* input, grpc_slice_buffer* output) {
+std::optional<SliceBuffer> MessageCompress(grpc_compression_algorithm algorithm,
+                                           const SliceBuffer& input) {
   switch (algorithm) {
     case GRPC_COMPRESS_NONE:
       // the fallback path always needs to be send uncompressed: we simply
       // rely on that here
-      return 0;
+      return std::nullopt;
     case GRPC_COMPRESS_DEFLATE:
-      return zlib_compress(input, output, 0);
+      return ZlibCompress(input, 0);
     case GRPC_COMPRESS_GZIP:
-      return zlib_compress(input, output, 1);
+      return ZlibCompress(input, 1);
     case GRPC_COMPRESS_ALGORITHMS_COUNT:
       break;
   }
   LOG(ERROR) << "invalid compression algorithm " << algorithm;
-  return 0;
+  return std::nullopt;
 }
 
+absl::StatusOr<SliceBuffer> MessageDecompress(
+    grpc_compression_algorithm algorithm, const SliceBuffer& input,
+    std::optional<uint32_t> max_output_size) {
+  switch (algorithm) {
+    case GRPC_COMPRESS_NONE: {
+      SliceBuffer output;
+      output.Append(input);
+      return output;
+    }
+    case GRPC_COMPRESS_DEFLATE:
+      return ZlibDecompress(input, 0, max_output_size);
+    case GRPC_COMPRESS_GZIP:
+      return ZlibDecompress(input, 1, max_output_size);
+    case GRPC_COMPRESS_ALGORITHMS_COUNT:
+      break;
+  }
+  LOG(ERROR) << "invalid compression algorithm " << algorithm;
+  return absl::InternalError("Invalid compression algorithm");
+}
+
+}  // namespace grpc_core
+
 int grpc_msg_compress(grpc_compression_algorithm algorithm,
                       grpc_slice_buffer* input, grpc_slice_buffer* output) {
-  if (!compress_inner(algorithm, input, output)) {
-    copy(input, output);
-    return 0;
+  int retval = 1;
+  grpc_core::SliceBuffer input_sb;
+  grpc_slice_buffer_swap(input, input_sb.c_slice_buffer());
+  std::optional<grpc_core::SliceBuffer> output_sb =
+      grpc_core::MessageCompress(algorithm, input_sb);
+  if (!output_sb.has_value()) {
+    output_sb.emplace();
+    output_sb->Append(input_sb);
+    retval = 0;
   }
-  return 1;
+  grpc_slice_buffer_swap(input, input_sb.c_slice_buffer());
+  grpc_slice_buffer_swap(output, output_sb->c_slice_buffer());
+  return retval;
 }
 
 int grpc_msg_decompress(grpc_compression_algorithm algorithm,
                         grpc_slice_buffer* input, grpc_slice_buffer* output) {
-  switch (algorithm) {
-    case GRPC_COMPRESS_NONE:
-      return copy(input, output);
-    case GRPC_COMPRESS_DEFLATE:
-      return zlib_decompress(input, output, 0);
-    case GRPC_COMPRESS_GZIP:
-      return zlib_decompress(input, output, 1);
-    case GRPC_COMPRESS_ALGORITHMS_COUNT:
-      break;
+  grpc_core::SliceBuffer input_sb;
+  grpc_slice_buffer_swap(input, input_sb.c_slice_buffer());
+
+  absl::StatusOr<grpc_core::SliceBuffer> output_sb =
+      grpc_core::MessageDecompress(algorithm, input_sb, std::nullopt);
+  if (!output_sb.ok()) {
+    return 0;
   }
-  LOG(ERROR) << "invalid compression algorithm " << algorithm;
-  return 0;
+  grpc_slice_buffer_swap(input, input_sb.c_slice_buffer());
+  grpc_slice_buffer_swap(output, output_sb->c_slice_buffer());
+  return 1;
 }

data/src/core/lib/compression/message_compress.h

@@ -23,6 +23,13 @@
 #include <grpc/slice.h>
 #include <grpc/support/port_platform.h>
 
+#include <cstdint>
+#include <optional>
+
+#include "src/core/lib/slice/slice_buffer.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+
 // compress 'input' to 'output' using 'algorithm'.
 // On success, appends compressed slices to output and returns 1.
 // On failure, appends uncompressed slices to output and returns 0.
@@ -35,4 +42,21 @@ int grpc_msg_compress(grpc_compression_algorithm algorithm,
 int grpc_msg_decompress(grpc_compression_algorithm algorithm,
                         grpc_slice_buffer* input, grpc_slice_buffer* output);
 
+namespace grpc_core {
+
+// Compresses 'input' using 'algorithm'.
+// On success, returns a SliceBuffer containing the compressed data.
+// On failure, returns nullopt.
+std::optional<SliceBuffer> MessageCompress(grpc_compression_algorithm algorithm,
+                                           const SliceBuffer& input);
+// Decompresses 'input'.
+// On success, returns a SliceBuffer containing the decompressed data.
+// On failure, returns a non-OK status.
+// Fails if the decompressed data would be larger than max_output_size.
+absl::StatusOr<SliceBuffer> MessageDecompress(
+    grpc_compression_algorithm algorithm, const SliceBuffer& input,
+    std::optional<uint32_t> max_output_size);
+
+}  // namespace grpc_core
+
 #endif  // GRPC_SRC_CORE_LIB_COMPRESSION_MESSAGE_COMPRESS_H

data/src/core/lib/event_engine/extensions/chaotic_good_extension.h

@@ -42,19 +42,6 @@ class ChaoticGoodExtension {
   /// one provided to it through the channel args. It is safe to call this
   /// only when there are no outstanding Reads on the Endpoint.
   virtual void UseMemoryQuota(grpc_core::MemoryQuotaRefPtr mem_quota) = 0;
-
-  /// Forces the endpoint to receive rpcs in one contiguous block of memory.
-  /// It is safe to call this only when there are no outstanding Reads on
-  /// the Endpoint.
-  virtual void EnableRpcReceiveCoalescing() = 0;
-
-  /// Disables rpc receive coalescing until it is explicitly enabled again.
-  /// It is safe to call this only when there are no outstanding Reads on
-  /// the Endpoint.
-  virtual void DisableRpcReceiveCoalescing() = 0;
-  /// If invoked, the endpoint tries to preserve proper order and alignment of
-  /// any memory that maybe shared across reads.
-  virtual void EnforceRxMemoryAlignment() = 0;
 };
 
 }  // namespace grpc_event_engine::experimental

data/src/core/lib/event_engine/extensions/receive_coalescing_extension.h

@@ -0,0 +1,44 @@
+// Copyright 2026 The gRPC Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_RECEIVE_COALESCING_EXTENSION_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_RECEIVE_COALESCING_EXTENSION_H
+
+#include "absl/strings/string_view.h"
+
+namespace grpc_event_engine::experimental {
+
+/// An Endpoint extension class that will be supported by EventEngine endpoints
+/// which need to work with receive coalescing.
+class ReceiveCoalescingExtension {
+ public:
+  virtual ~ReceiveCoalescingExtension() = default;
+  static absl::string_view EndpointExtensionName() {
+    return "io.grpc.event_engine.extension.receive_coalescing_extension";
+  }
+
+  /// Forces the endpoint to receive rpcs in one contiguous block of memory.
+  /// It is safe to call this only when there are no outstanding Reads on
+  /// the Endpoint.
+  virtual void EnableRpcReceiveCoalescing() = 0;
+
+  /// Disables rpc receive coalescing until it is explicitly enabled again.
+  /// It is safe to call this only when there are no outstanding Reads on
+  /// the Endpoint.
+  virtual void DisableRpcReceiveCoalescing() = 0;
+};
+
+}  // namespace grpc_event_engine::experimental
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_RECEIVE_COALESCING_EXTENSION_H

data/src/core/lib/event_engine/extensions/tcp_trace.h

@@ -36,7 +36,7 @@ class TcpTraceExtension {
   // Enable TCP telemetry collection using the Instrumentation API.
   virtual void EnableTcpTelemetry(
       grpc_core::RefCountedPtr<grpc_core::CollectionScope> collection_scope,
-      bool is_control_endpoint) = 0;
+      bool is_control_endpoint, bool trace_full_buffer) = 0;
 };
 
 }  // namespace grpc_event_engine::experimental

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

@@ -22,6 +22,7 @@
 
 #include "src/core/lib/event_engine/extensions/can_track_errors.h"
 #include "src/core/lib/event_engine/extensions/chaotic_good_extension.h"
+#include "src/core/lib/event_engine/extensions/receive_coalescing_extension.h"
 #include "src/core/lib/event_engine/extensions/supports_fd.h"
 #include "src/core/lib/event_engine/query_extensions.h"
 
@@ -31,6 +32,7 @@ namespace grpc_event_engine::experimental {
 /// may implement to support additional chaotic good related functionality.
 class PosixEndpointWithChaoticGoodSupport
     : public ExtendedType<EventEngine::Endpoint, ChaoticGoodExtension,
+                          ReceiveCoalescingExtension,
                           EndpointSupportsFdExtension,
                           EndpointCanTrackErrorsExtension> {};
 

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

@@ -95,7 +95,8 @@ NativePosixDNSResolver::NativePosixDNSResolver(
 void NativePosixDNSResolver::LookupHostname(
     EventEngine::DNSResolver::LookupHostnameCallback on_resolved,
     absl::string_view name, absl::string_view default_port) {
-  event_engine_->Run([name = std::string(name), default_port,
+  event_engine_->Run([name = std::string(name),
+                      default_port = std::string(default_port),
                       on_resolved = std::move(on_resolved)]() mutable {
     on_resolved(LookupHostnameBlocking(name, default_port));
   });

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

@@ -29,6 +29,7 @@
 #include <memory>
 #include <optional>
 #include <string>
+#include <utility>
 
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/event_engine/posix_engine/event_poller.h"
@@ -44,7 +45,6 @@
 #include "src/core/util/load_file.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/status_helper.h"
-#include "src/core/util/strerror.h"
 #include "src/core/util/sync.h"
 #include "absl/functional/any_invocable.h"
 #include "absl/log/log.h"
@@ -136,10 +136,11 @@ uint64_t ParseUlimitMemLockFromFile(std::string file_name) {
     return 0;
   }
   // Find position of next newline after prefix.
-  size_t end = file_contents.find(start, '\n');
+  size_t end = file_contents.find('\n', start);
   // Extract substring between prefix and next newline.
+  size_t value_start = start + kHardMemlockPrefix.length() + 1;
   auto memlock_value_string = file_contents.substr(
-      start + kHardMemlockPrefix.length() + 1, end - start);
+      value_start, end == std::string::npos ? end : end - value_start);
   rtrim(memlock_value_string);
   if (memlock_value_string == "unlimited" ||
       memlock_value_string == "infinity") {
@@ -370,8 +371,8 @@ bool PosixEndpointImpl::TcpDoRead(absl::Status& status) {
       } else if (read_bytes == 0) {
         status = TcpAnnotateError(absl::InternalError("Socket closed"));
       } else {
-        status = TcpAnnotateError(absl::InternalError(
-            absl::StrCat("recvmsg:", grpc_core::StrError(errno))));
+        status = TcpAnnotateError(
+            absl::InternalError(absl::StrCat("recvmsg:", res.StrError())));
       }
       return true;
     }
@@ -892,7 +893,7 @@ bool PosixEndpointImpl::WriteWithTimestamps(struct msghdr* msg,
   traced_buffers_.AddNewEntry(
       static_cast<uint32_t>(bytes_counter_ + sending_length),
       &poller_->posix_interface(), handle_->WrappedFd(),
-      std::move(outgoing_buffer_write_event_sink_).value());
+      std::move(*outgoing_buffer_write_event_sink_));
   outgoing_buffer_write_event_sink_.reset();
 
   // If there was an error on sendmsg the logic in tcp_flush will handle it.
@@ -940,6 +941,7 @@ void PosixEndpointImpl::UnrefMaybePutZerocopySendRecord(
 void PosixEndpointImpl::TcpShutdownTracedBufferList() {
   if (outgoing_buffer_write_event_sink_.has_value()) {
     traced_buffers_.Shutdown(std::move(outgoing_buffer_write_event_sink_));
+    outgoing_buffer_write_event_sink_.reset();
   }
 }
 
@@ -1134,6 +1136,7 @@ bool PosixEndpointImpl::TcpFlush(absl::Status& status) {
     }
 
     GRPC_CHECK_EQ(outgoing_byte_idx_, 0u);
+    GRPC_CHECK_LE((static_cast<size_t>(*send_result)), sending_length);
     bytes_counter_ += *send_result;
     trailing = sending_length - static_cast<size_t>(*send_result);
     while (trailing > 0) {
@@ -1270,7 +1273,7 @@ void PosixEndpointImpl::MaybeShutdown(
   Unref();
 }
 
-PosixEndpointImpl ::~PosixEndpointImpl() {
+PosixEndpointImpl::~PosixEndpointImpl() {
   FileDescriptor release_fd;
   handle_->OrphanHandle(on_done_,
                         on_release_fd_ == nullptr ? nullptr : &release_fd, "");
@@ -1327,7 +1330,7 @@ PosixEndpointImpl::PosixEndpointImpl(EventHandle* handle,
                  << "ulimit value is not set. Use ulimit -l <value> to set its "
                  << "value.";
     } else {
-      if (posix_interface.SetSockOpt(fd, SOL_SOCKET, SO_ZEROCOPY, 1).ok()) {
+      if (!posix_interface.SetSockOpt(fd, SOL_SOCKET, SO_ZEROCOPY, 1).ok()) {
         zerocopy_enabled = false;
         LOG(ERROR) << "Failed to set zerocopy options on the socket.";
       }

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

@@ -44,6 +44,7 @@
 #include "src/core/util/crash.h"
 #include "src/core/util/fork.h"
 #include "src/core/util/grpc_check.h"
+#include "src/core/util/strerror.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/useful.h"
 #include "absl/base/no_destructor.h"
@@ -75,14 +76,6 @@ namespace grpc_event_engine::experimental {
 
 namespace {
 
-bool ShouldUsePosixPoller() {
-#if defined(GRPC_PYTHON_BUILD)
-  return grpc_core::IsEventEnginePollerForPythonEnabled();
-#else
-  return true;
-#endif
-}
-
 #if GRPC_ENABLE_FORK_SUPPORT && GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK
 
 // Thread pool can outlive EE but we need to ensure the ordering if both
@@ -255,7 +248,7 @@ void AsyncConnect::Start(EventEngine::Duration timeout) {
   fd_->NotifyOnWrite(on_writable_);
 }
 
-AsyncConnect ::~AsyncConnect() { delete on_writable_; }
+AsyncConnect::~AsyncConnect() { delete on_writable_; }
 
 void AsyncConnect::OnTimeoutExpired(absl::Status status) {
   bool done = false;
@@ -383,13 +376,13 @@ void AsyncConnect::OnWritable(absl::Status status)
       return;
     case ECONNREFUSED:
       // This error shouldn't happen for anything other than connect().
-      status = absl::FailedPreconditionError(std::strerror(so_error));
+      status = absl::FailedPreconditionError(grpc_core::StrError(so_error));
       break;
     default:
       // We don't really know which syscall triggered the problem here, so
       // punt by reporting getsockopt().
-      status = absl::FailedPreconditionError(
-          absl::StrCat("getsockopt(SO_ERROR): ", std::strerror(so_error)));
+      status = absl::FailedPreconditionError(absl::StrCat(
+          "getsockopt(SO_ERROR): ", grpc_core::StrError(so_error)));
       break;
   }
 }
@@ -433,10 +426,8 @@ PosixEventEngine::PosixEventEngine(const Options& options)
     : connection_shards_(options.connection_shards),
       executor_(MakeThreadPool(options.reserve_threads)),
       timer_manager_(std::make_shared<TimerManager>(executor_)) {
-  if (ShouldUsePosixPoller()) {
-    poller_ = grpc_event_engine::experimental::MakeDefaultPoller(executor_);
-    SchedulePoller();
-  }
+  poller_ = grpc_event_engine::experimental::MakeDefaultPoller(executor_);
+  SchedulePoller();
 }
 
 #endif  // GRPC_POSIX_SOCKET_TCP
@@ -807,7 +798,7 @@ PosixEventEngine::CreateEndpointFromUnconnectedFdInternal(
     Run([on_connect = std::move(on_connect),
          ep = absl::FailedPreconditionError(absl::StrCat(
              "connect failed: ", "addr: ", addr_uri.value(),
-             " error: ", std::strerror(connect_errno)))]() mutable {
+             " error: ", grpc_core::StrError(connect_errno)))]() mutable {
       on_connect(std::move(ep));
     });
     return EventEngine::ConnectionHandle::kInvalid;
@@ -834,7 +825,7 @@ absl::StatusOr<std::unique_ptr<EventEngine::Endpoint>>
 PosixEventEngine::CreatePosixEndpointFromFd(int fd,
                                             const EndpointConfig& config,
                                             MemoryAllocator memory_allocator) {
-  GRPC_DCHECK_GT(fd, 0);
+  GRPC_DCHECK_GE(fd, 0);
   if (poller_ == nullptr) {
     return absl::FailedPreconditionError("polling is not enabled");
   }

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

@@ -198,7 +198,7 @@ void PosixEngineListenerImpl::AsyncConnectionAcceptor::NotifyOnAccept(
       auto peer_address = posix_interface.PeerAddress(fd.value());
       if (!peer_address.ok()) {
         auto listener_addr_uri = ResolvedAddressToURI(socket_.addr);
-        LOG(ERROR) << "Failed getpeername: " << grpc_core::StrError(errno)
+        LOG(ERROR) << "Failed getpeername: " << peer_address.status()
                    << ". Dropping the connection, and continuing "
                       "to listen on "
                    << (listener_addr_uri.ok() ? *listener_addr_uri

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

@@ -31,6 +31,7 @@
 #include "src/core/util/crash.h"  // IWYU pragma: keep
 #include "src/core/util/grpc_check.h"
 #include "src/core/util/status_helper.h"
+#include "src/core/util/strerror.h"
 #include "absl/cleanup/cleanup.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
@@ -274,7 +275,7 @@ absl::StatusOr<int> ListenerContainerAddAllLocalAddresses(
   }
   if (getifaddrs(&ifa) != 0 || ifa == nullptr) {
     return absl::FailedPreconditionError(
-        absl::StrCat("getifaddrs: ", std::strerror(errno)));
+        absl::StrCat("getifaddrs: ", grpc_core::StrError(errno)));
   }
 
   static const bool is_ipv4_available = [] {