grpc 1.55.0 → 1.56.2

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

@@ -1,4 +1,4 @@
-// Copyright 2022 gRPC authors.
+// Copyright 2023 gRPC authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// Automatically generated by tools/codegen/core/gen_experiments.py
+// Auto generated by tools/codegen/core/gen_experiments.py
 
 #include <grpc/support/port_platform.h>
 
@@ -25,66 +25,113 @@ const char* const description_tcp_frame_size_tuning =
     "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.";
+const char* const additional_constraints_tcp_frame_size_tuning = "{}";
 const char* const description_tcp_rcv_lowat =
     "Use SO_RCVLOWAT to avoid wakeups on the read path.";
+const char* const additional_constraints_tcp_rcv_lowat = "{}";
 const char* const description_peer_state_based_framing =
     "If set, the max sizes of frames sent to lower layers is controlled based "
     "on the peer's memory pressure which is reflected in its max http2 frame "
     "size.";
-const char* const description_flow_control_fixes =
-    "Various fixes for flow control, max frame size setting.";
+const char* const additional_constraints_peer_state_based_framing = "{}";
 const char* const description_memory_pressure_controller =
     "New memory pressure controller";
+const char* const additional_constraints_memory_pressure_controller = "{}";
 const char* const description_unconstrained_max_quota_buffer_size =
     "Discard the cap on the max free pool size for one memory allocator";
+const char* const additional_constraints_unconstrained_max_quota_buffer_size =
+    "{}";
 const char* const description_event_engine_client =
     "Use EventEngine clients instead of iomgr's grpc_tcp_client";
+const char* const additional_constraints_event_engine_client = "{}";
 const char* const description_monitoring_experiment =
     "Placeholder experiment to prove/disprove our monitoring is working";
+const char* const additional_constraints_monitoring_experiment = "{}";
 const char* const description_promise_based_client_call =
     "If set, use the new gRPC promise based call code when it's appropriate "
     "(ie when all filters in a stack are promise based)";
+const char* const additional_constraints_promise_based_client_call = "{}";
 const char* const description_free_large_allocator =
     "If set, return all free bytes from a \042big\042 allocator";
+const char* const additional_constraints_free_large_allocator = "{}";
 const char* const description_promise_based_server_call =
     "If set, use the new gRPC promise based call code when it's appropriate "
     "(ie when all filters in a stack are promise based)";
+const char* const additional_constraints_promise_based_server_call = "{}";
 const char* const description_transport_supplies_client_latency =
     "If set, use the transport represented value for client latency in "
     "opencensus";
+const char* const additional_constraints_transport_supplies_client_latency =
+    "{}";
 const char* const description_event_engine_listener =
     "Use EventEngine listeners instead of iomgr's grpc_tcp_server";
+const char* const additional_constraints_event_engine_listener = "{}";
 const char* const description_schedule_cancellation_over_write =
     "Allow cancellation op to be scheduled over a write";
+const char* const additional_constraints_schedule_cancellation_over_write =
+    "{}";
 const char* const description_trace_record_callops =
     "Enables tracing of call batch initiation and completion.";
+const char* const additional_constraints_trace_record_callops = "{}";
 const char* const description_event_engine_dns =
     "If set, use EventEngine DNSResolver for client channel resolution";
+const char* const additional_constraints_event_engine_dns = "{}";
+const char* const description_work_stealing =
+    "If set, use a work stealing thread pool implementation in EventEngine";
+const char* const additional_constraints_work_stealing = "{}";
+const char* const description_client_privacy = "If set, client privacy";
+const char* const additional_constraints_client_privacy = "{}";
+const char* const description_canary_client_privacy =
+    "If set, canary client privacy";
+const char* const additional_constraints_canary_client_privacy = "{}";
+const char* const description_server_privacy = "If set, server privacy";
+const char* const additional_constraints_server_privacy = "{}";
 }  // namespace
 
 namespace grpc_core {
 
 const ExperimentMetadata g_experiment_metadata[] = {
-    {"tcp_frame_size_tuning", description_tcp_frame_size_tuning, false},
-    {"tcp_rcv_lowat", description_tcp_rcv_lowat, false},
-    {"peer_state_based_framing", description_peer_state_based_framing, false},
-    {"flow_control_fixes", description_flow_control_fixes, true},
+    {"tcp_frame_size_tuning", description_tcp_frame_size_tuning,
+     additional_constraints_tcp_frame_size_tuning, false, true},
+    {"tcp_rcv_lowat", description_tcp_rcv_lowat,
+     additional_constraints_tcp_rcv_lowat, false, true},
+    {"peer_state_based_framing", description_peer_state_based_framing,
+     additional_constraints_peer_state_based_framing, false, true},
     {"memory_pressure_controller", description_memory_pressure_controller,
-     false},
+     additional_constraints_memory_pressure_controller, false, true},
     {"unconstrained_max_quota_buffer_size",
-     description_unconstrained_max_quota_buffer_size, false},
-    {"event_engine_client", description_event_engine_client, false},
-    {"monitoring_experiment", description_monitoring_experiment, true},
-    {"promise_based_client_call", description_promise_based_client_call, false},
-    {"free_large_allocator", description_free_large_allocator, false},
-    {"promise_based_server_call", description_promise_based_server_call, false},
+     description_unconstrained_max_quota_buffer_size,
+     additional_constraints_unconstrained_max_quota_buffer_size, false, true},
+    {"event_engine_client", description_event_engine_client,
+     additional_constraints_event_engine_client, false, true},
+    {"monitoring_experiment", description_monitoring_experiment,
+     additional_constraints_monitoring_experiment, true, true},
+    {"promise_based_client_call", description_promise_based_client_call,
+     additional_constraints_promise_based_client_call, false, true},
+    {"free_large_allocator", description_free_large_allocator,
+     additional_constraints_free_large_allocator, false, true},
+    {"promise_based_server_call", description_promise_based_server_call,
+     additional_constraints_promise_based_server_call, false, true},
     {"transport_supplies_client_latency",
-     description_transport_supplies_client_latency, false},
-    {"event_engine_listener", description_event_engine_listener, false},
+     description_transport_supplies_client_latency,
+     additional_constraints_transport_supplies_client_latency, false, true},
+    {"event_engine_listener", description_event_engine_listener,
+     additional_constraints_event_engine_listener, false, true},
     {"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},
+     description_schedule_cancellation_over_write,
+     additional_constraints_schedule_cancellation_over_write, false, true},
+    {"trace_record_callops", description_trace_record_callops,
+     additional_constraints_trace_record_callops, false, true},
+    {"event_engine_dns", description_event_engine_dns,
+     additional_constraints_event_engine_dns, false, false},
+    {"work_stealing", description_work_stealing,
+     additional_constraints_work_stealing, false, false},
+    {"client_privacy", description_client_privacy,
+     additional_constraints_client_privacy, false, false},
+    {"canary_client_privacy", description_canary_client_privacy,
+     additional_constraints_canary_client_privacy, false, false},
+    {"server_privacy", description_server_privacy,
+     additional_constraints_server_privacy, false, false},
 };
 
 }  // namespace grpc_core

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

@@ -1,4 +1,4 @@
-// Copyright 2022 gRPC authors.
+// Copyright 2023 gRPC authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// Automatically generated by tools/codegen/core/gen_experiments.py
+// Auto generated by tools/codegen/core/gen_experiments.py
 //
 // This file contains the autogenerated parts of the experiments API.
 //
@@ -60,8 +60,6 @@ namespace grpc_core {
 inline bool IsTcpFrameSizeTuningEnabled() { return false; }
 inline bool IsTcpRcvLowatEnabled() { return false; }
 inline bool IsPeerStateBasedFramingEnabled() { return false; }
-#define GRPC_EXPERIMENT_IS_INCLUDED_FLOW_CONTROL_FIXES
-inline bool IsFlowControlFixesEnabled() { return true; }
 inline bool IsMemoryPressureControllerEnabled() { return false; }
 inline bool IsUnconstrainedMaxQuotaBufferSizeEnabled() { return false; }
 inline bool IsEventEngineClientEnabled() { return false; }
@@ -75,6 +73,10 @@ inline bool IsEventEngineListenerEnabled() { return false; }
 inline bool IsScheduleCancellationOverWriteEnabled() { return false; }
 inline bool IsTraceRecordCallopsEnabled() { return false; }
 inline bool IsEventEngineDnsEnabled() { return false; }
+inline bool IsWorkStealingEnabled() { return false; }
+inline bool IsClientPrivacyEnabled() { return false; }
+inline bool IsCanaryClientPrivacyEnabled() { return false; }
+inline bool IsServerPrivacyEnabled() { return false; }
 #else
 #define GRPC_EXPERIMENT_IS_INCLUDED_TCP_FRAME_SIZE_TUNING
 inline bool IsTcpFrameSizeTuningEnabled() { return IsExperimentEnabled(0); }
@@ -82,44 +84,48 @@ inline bool IsTcpFrameSizeTuningEnabled() { return IsExperimentEnabled(0); }
 inline bool IsTcpRcvLowatEnabled() { return IsExperimentEnabled(1); }
 #define GRPC_EXPERIMENT_IS_INCLUDED_PEER_STATE_BASED_FRAMING
 inline bool IsPeerStateBasedFramingEnabled() { return IsExperimentEnabled(2); }
-#define GRPC_EXPERIMENT_IS_INCLUDED_FLOW_CONTROL_FIXES
-inline bool IsFlowControlFixesEnabled() { return IsExperimentEnabled(3); }
 #define GRPC_EXPERIMENT_IS_INCLUDED_MEMORY_PRESSURE_CONTROLLER
 inline bool IsMemoryPressureControllerEnabled() {
-  return IsExperimentEnabled(4);
+  return IsExperimentEnabled(3);
 }
 #define GRPC_EXPERIMENT_IS_INCLUDED_UNCONSTRAINED_MAX_QUOTA_BUFFER_SIZE
 inline bool IsUnconstrainedMaxQuotaBufferSizeEnabled() {
-  return IsExperimentEnabled(5);
+  return IsExperimentEnabled(4);
 }
 #define GRPC_EXPERIMENT_IS_INCLUDED_EVENT_ENGINE_CLIENT
-inline bool IsEventEngineClientEnabled() { return IsExperimentEnabled(6); }
+inline bool IsEventEngineClientEnabled() { return IsExperimentEnabled(5); }
 #define GRPC_EXPERIMENT_IS_INCLUDED_MONITORING_EXPERIMENT
-inline bool IsMonitoringExperimentEnabled() { return IsExperimentEnabled(7); }
+inline bool IsMonitoringExperimentEnabled() { return IsExperimentEnabled(6); }
 #define GRPC_EXPERIMENT_IS_INCLUDED_PROMISE_BASED_CLIENT_CALL
-inline bool IsPromiseBasedClientCallEnabled() { return IsExperimentEnabled(8); }
+inline bool IsPromiseBasedClientCallEnabled() { return IsExperimentEnabled(7); }
 #define GRPC_EXPERIMENT_IS_INCLUDED_FREE_LARGE_ALLOCATOR
-inline bool IsFreeLargeAllocatorEnabled() { return IsExperimentEnabled(9); }
+inline bool IsFreeLargeAllocatorEnabled() { return IsExperimentEnabled(8); }
 #define GRPC_EXPERIMENT_IS_INCLUDED_PROMISE_BASED_SERVER_CALL
-inline bool IsPromiseBasedServerCallEnabled() {
-  return IsExperimentEnabled(10);
-}
+inline bool IsPromiseBasedServerCallEnabled() { return IsExperimentEnabled(9); }
 #define GRPC_EXPERIMENT_IS_INCLUDED_TRANSPORT_SUPPLIES_CLIENT_LATENCY
 inline bool IsTransportSuppliesClientLatencyEnabled() {
-  return IsExperimentEnabled(11);
+  return IsExperimentEnabled(10);
 }
 #define GRPC_EXPERIMENT_IS_INCLUDED_EVENT_ENGINE_LISTENER
-inline bool IsEventEngineListenerEnabled() { return IsExperimentEnabled(12); }
+inline bool IsEventEngineListenerEnabled() { return IsExperimentEnabled(11); }
 #define GRPC_EXPERIMENT_IS_INCLUDED_SCHEDULE_CANCELLATION_OVER_WRITE
 inline bool IsScheduleCancellationOverWriteEnabled() {
-  return IsExperimentEnabled(13);
+  return IsExperimentEnabled(12);
 }
 #define GRPC_EXPERIMENT_IS_INCLUDED_TRACE_RECORD_CALLOPS
-inline bool IsTraceRecordCallopsEnabled() { return IsExperimentEnabled(14); }
+inline bool IsTraceRecordCallopsEnabled() { return IsExperimentEnabled(13); }
 #define GRPC_EXPERIMENT_IS_INCLUDED_EVENT_ENGINE_DNS
-inline bool IsEventEngineDnsEnabled() { return IsExperimentEnabled(15); }
+inline bool IsEventEngineDnsEnabled() { return IsExperimentEnabled(14); }
+#define GRPC_EXPERIMENT_IS_INCLUDED_WORK_STEALING
+inline bool IsWorkStealingEnabled() { return IsExperimentEnabled(15); }
+#define GRPC_EXPERIMENT_IS_INCLUDED_CLIENT_PRIVACY
+inline bool IsClientPrivacyEnabled() { return IsExperimentEnabled(16); }
+#define GRPC_EXPERIMENT_IS_INCLUDED_CANARY_CLIENT_PRIVACY
+inline bool IsCanaryClientPrivacyEnabled() { return IsExperimentEnabled(17); }
+#define GRPC_EXPERIMENT_IS_INCLUDED_SERVER_PRIVACY
+inline bool IsServerPrivacyEnabled() { return IsExperimentEnabled(18); }
 
-constexpr const size_t kNumExperiments = 16;
+constexpr const size_t kNumExperiments = 19;
 extern const ExperimentMetadata g_experiment_metadata[kNumExperiments];
 
 #endif

data/src/core/lib/gpr/log_internal.h

@@ -0,0 +1,55 @@
+// Copyright 2022 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_GPR_LOG_INTERNAL_H
+#define GRPC_SRC_CORE_LIB_GPR_LOG_INTERNAL_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <cstring>
+
+/// abort() the process if x is zero, with rudimentary logging to prevent
+/// circular dependencies with gpr_log.
+
+/// Intended for internal invariants.  If the error can be recovered from,
+/// without the possibility of corruption, or might best be reflected via
+/// an exception in a higher-level language, consider returning error code.
+#define GPR_ASSERT_INTERNAL(x)                     \
+  do {                                             \
+    if (GPR_UNLIKELY(!(x))) {                      \
+      fprintf(stderr, "assertion failed: %s", #x); \
+      abort();                                     \
+    }                                              \
+  } while (0)
+
+#ifndef NDEBUG
+#define GPR_DEBUG_ASSERT_INTERNAL(x) GPR_ASSERT_INTERNAL(x)
+#else
+#define GPR_DEBUG_ASSERT_INTERNAL(x)
+#endif
+
+#define GPR_LOG_ERROR_INTERNAL(format, ...)                       \
+  do {                                                            \
+    char f[] = __FILE__;                                          \
+    char* display_file = f;                                       \
+    char* slash_pos = strrchr(f, '/');                            \
+    if (slash_pos != nullptr) display_file = slash_pos + 1;       \
+    char prefix[60];                                              \
+    sprintf(prefix, "INTERNAL %37s:%d]", display_file, __LINE__); \
+    fprintf(stderr, "%-60s " format "\n", prefix, __VA_ARGS__);   \
+  } while (0)
+
+#endif  // GRPC_SRC_CORE_LIB_GPR_LOG_INTERNAL_H

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

@@ -16,10 +16,13 @@
 
 #include "src/core/lib/gprpp/crash.h"
 
+#include <stdio.h>
 #include <stdlib.h>
 
 #include <string>
 
+#include "absl/strings/str_cat.h"
+
 #include <grpc/support/log.h>
 
 namespace grpc_core {
@@ -30,4 +33,11 @@ void Crash(absl::string_view message, SourceLocation location) {
   abort();
 }
 
+void CrashWithStdio(absl::string_view message, SourceLocation location) {
+  fputs(absl::StrCat(location.file(), ":", location.line(), ": ", message, "\n")
+            .c_str(),
+        stderr);
+  abort();
+}
+
 }  // namespace grpc_core

data/src/core/lib/gprpp/crash.h

@@ -29,6 +29,9 @@ namespace grpc_core {
 [[noreturn]] void Crash(absl::string_view message,
                         ::grpc_core::SourceLocation location = {});
 
+[[noreturn]] void CrashWithStdio(absl::string_view message,
+                                 ::grpc_core::SourceLocation location = {});
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_GPRPP_CRASH_H

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

@@ -0,0 +1,33 @@
+// Copyright 2023 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.
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/gprpp/per_cpu.h"
+
+#include <grpc/support/cpu.h>
+
+#include "src/core/lib/gpr/useful.h"
+
+namespace grpc_core {
+
+size_t PerCpuOptions::Shards() {
+  return ShardsForCpuCount(gpr_cpu_num_cores());
+}
+
+size_t PerCpuOptions::ShardsForCpuCount(size_t cpu_count) {
+  return Clamp<size_t>(cpu_count / cpus_per_shard_, 1, max_shards_);
+}
+
+}  // namespace grpc_core

data/src/core/lib/gprpp/per_cpu.h

@@ -22,18 +22,41 @@
 #include <limits>
 #include <memory>
 
-#include <grpc/support/cpu.h>
-
 #include "src/core/lib/iomgr/exec_ctx.h"
 
 namespace grpc_core {
 
+class PerCpuOptions {
+ public:
+  // Set the number of cpus that colocate on the same shard
+  PerCpuOptions SetCpusPerShard(size_t cpus_per_shard) {
+    cpus_per_shard_ = std::max<size_t>(1, cpus_per_shard);
+    return *this;
+  }
+
+  // Set the maximum number of allowable shards
+  PerCpuOptions SetMaxShards(size_t max_shards) {
+    max_shards_ = std::max<size_t>(1, max_shards);
+    return *this;
+  }
+
+  size_t cpus_per_shard() const { return cpus_per_shard_; }
+  size_t max_shards() const { return max_shards_; }
+
+  size_t Shards();
+  size_t ShardsForCpuCount(size_t cpu_count);
+
+ private:
+  size_t cpus_per_shard_ = 1;
+  size_t max_shards_ = std::numeric_limits<size_t>::max();
+};
+
 template <typename T>
 class PerCpu {
  public:
-  explicit PerCpu(size_t max = std::numeric_limits<size_t>::max())
-      : cpus_(std::min<size_t>(max, gpr_cpu_num_cores())),
-        data_{new T[cpus_]} {}
+  // Options are not defaulted to try and force consideration of what the
+  // options specify.
+  explicit PerCpu(PerCpuOptions options) : cpus_(options.Shards()) {}
 
   T& this_cpu() { return data_[ExecCtx::Get()->starting_cpu() % cpus_]; }
 
@@ -44,7 +67,7 @@ class PerCpu {
 
  private:
   const size_t cpus_;
-  std::unique_ptr<T[]> data_;
+  std::unique_ptr<T[]> data_{new T[cpus_]};
 };
 
 }  // namespace grpc_core

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

@@ -229,6 +229,7 @@ Duration::operator grpc_event_engine::experimental::EventEngine::Duration()
 void TestOnlySetProcessEpoch(gpr_timespec epoch) {
   g_process_epoch_seconds.store(
       gpr_convert_clock_type(epoch, GPR_CLOCK_MONOTONIC).tv_sec);
+  g_process_epoch_cycles.store(gpr_get_cycle_counter());
 }
 
 std::ostream& operator<<(std::ostream& out, Timestamp timestamp) {

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

@@ -188,7 +188,7 @@ void CFStreamHandle::Ref(const char* file, int line, const char* reason) {
 void CFStreamHandle::Unref(const char* file, int line, const char* reason) {
   if (grpc_tcp_trace.enabled()) {
     gpr_atm val = gpr_atm_no_barrier_load(&refcount_.count);
-    gpr_log(GPR_DEBUG,
+    gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
             "CFStream Handle unref %p : %s %" PRIdPTR " -> %" PRIdPTR, this,
             reason, val, val - 1);
   }

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

@@ -240,7 +240,7 @@ static void WriteAction(void* arg, grpc_error_handle error) {
 }
 
 static void CFStreamRead(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                         grpc_closure* cb, bool urgent,
+                         grpc_closure* cb, bool /*urgent*/,
                          int /*min_progress_size*/) {
   CFStreamEndpoint* ep_impl = reinterpret_cast<CFStreamEndpoint*>(ep);
   if (grpc_tcp_trace.enabled()) {
@@ -258,7 +258,8 @@ static void CFStreamRead(grpc_endpoint* ep, grpc_slice_buffer* slices,
 }
 
 static void CFStreamWrite(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                          grpc_closure* cb, void* arg, int /*max_frame_size*/) {
+                          grpc_closure* cb, void* /*arg*/,
+                          int /*max_frame_size*/) {
   CFStreamEndpoint* ep_impl = reinterpret_cast<CFStreamEndpoint*>(ep);
   if (grpc_tcp_trace.enabled()) {
     gpr_log(GPR_DEBUG, "CFStream endpoint:%p write (%p, %p) length:%zu",
@@ -304,14 +305,15 @@ absl::string_view CFStreamGetLocalAddress(grpc_endpoint* ep) {
   return ep_impl->local_address;
 }
 
-int CFStreamGetFD(grpc_endpoint* ep) { return 0; }
+int CFStreamGetFD(grpc_endpoint* /*ep*/) { return 0; }
 
-bool CFStreamCanTrackErr(grpc_endpoint* ep) { return false; }
+bool CFStreamCanTrackErr(grpc_endpoint* /*ep*/) { return false; }
 
-void CFStreamAddToPollset(grpc_endpoint* ep, grpc_pollset* pollset) {}
-void CFStreamAddToPollsetSet(grpc_endpoint* ep, grpc_pollset_set* pollset) {}
-void CFStreamDeleteFromPollsetSet(grpc_endpoint* ep,
-                                  grpc_pollset_set* pollset) {}
+void CFStreamAddToPollset(grpc_endpoint* /*ep*/, grpc_pollset* /*pollset*/) {}
+void CFStreamAddToPollsetSet(grpc_endpoint* /*ep*/,
+                             grpc_pollset_set* /*pollset*/) {}
+void CFStreamDeleteFromPollsetSet(grpc_endpoint* /*ep*/,
+                                  grpc_pollset_set* /*pollset*/) {}
 
 static const grpc_endpoint_vtable vtable = {CFStreamRead,
                                             CFStreamWrite,

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

@@ -118,7 +118,7 @@ static void grpc_apple_register_write_stream_queue(
 /// be issued to the run loop when a network event happens and will be driven by
 /// the global run loop thread gGlobalRunLoopThread.
 static void grpc_apple_register_read_stream_run_loop(
-    CFReadStreamRef read_stream, dispatch_queue_t dispatch_queue) {
+    CFReadStreamRef read_stream, dispatch_queue_t /*dispatch_queue*/) {
   GRPC_POLLING_TRACE("Register read stream: %p", read_stream);
   grpc_core::MutexLock lock(&gGlobalRunLoopContext->mu);
   CFReadStreamScheduleWithRunLoop(read_stream, gGlobalRunLoopContext->run_loop,
@@ -131,7 +131,7 @@ static void grpc_apple_register_read_stream_run_loop(
 /// be issued to the run loop when a network event happens, and will be driven
 /// by the global run loop thread gGlobalRunLoopThread.
 static void grpc_apple_register_write_stream_run_loop(
-    CFWriteStreamRef write_stream, dispatch_queue_t dispatch_queue) {
+    CFWriteStreamRef write_stream, dispatch_queue_t /*dispatch_queue*/) {
   GRPC_POLLING_TRACE("Register write stream: %p", write_stream);
   grpc_core::MutexLock lock(&gGlobalRunLoopContext->mu);
   CFWriteStreamScheduleWithRunLoop(
@@ -163,7 +163,7 @@ void grpc_apple_register_write_stream(CFWriteStreamRef write_stream,
 
 /// Drive the run loop in a global singleton thread until the global run loop is
 /// shutdown.
-static void GlobalRunLoopFunc(void* arg) {
+static void GlobalRunLoopFunc(void* /*arg*/) {
   grpc_core::LockableAndReleasableMutexLock lock(&gGlobalRunLoopContext->mu);
   gGlobalRunLoopContext->run_loop = CFRunLoopGetCurrent();
   gGlobalRunLoopContext->init_cv.Signal();
@@ -342,15 +342,15 @@ grpc_pollset_vtable grpc_apple_pollset_vtable = {
 // pollset_set implementation
 
 grpc_pollset_set* pollset_set_create(void) { return nullptr; }
-void pollset_set_destroy(grpc_pollset_set* pollset_set) {}
-void pollset_set_add_pollset(grpc_pollset_set* pollset_set,
-                             grpc_pollset* pollset) {}
-void pollset_set_del_pollset(grpc_pollset_set* pollset_set,
-                             grpc_pollset* pollset) {}
-void pollset_set_add_pollset_set(grpc_pollset_set* bag,
-                                 grpc_pollset_set* item) {}
-void pollset_set_del_pollset_set(grpc_pollset_set* bag,
-                                 grpc_pollset_set* item) {}
+void pollset_set_destroy(grpc_pollset_set* /*pollset_set*/) {}
+void pollset_set_add_pollset(grpc_pollset_set* /*pollset_set*/,
+                             grpc_pollset* /*pollset*/) {}
+void pollset_set_del_pollset(grpc_pollset_set* /*pollset_set*/,
+                             grpc_pollset* /*pollset*/) {}
+void pollset_set_add_pollset_set(grpc_pollset_set* /*bag*/,
+                                 grpc_pollset_set* /*item*/) {}
+void pollset_set_del_pollset_set(grpc_pollset_set* /*bag*/,
+                                 grpc_pollset_set* /*item*/) {}
 
 grpc_pollset_set_vtable grpc_apple_pollset_set_vtable = {
     pollset_set_create,          pollset_set_destroy,

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

@@ -61,6 +61,7 @@
 #include "src/core/lib/iomgr/wakeup_fd_posix.h"
 
 static grpc_wakeup_fd global_wakeup_fd;
+static bool g_is_shutdown = true;
 
 //******************************************************************************
 // Singleton epoll set related fields
@@ -1239,6 +1240,7 @@ static void shutdown_engine(void) {
     gpr_mu_destroy(&fork_fd_list_mu);
     grpc_core::Fork::SetResetChildPollingEngineFunc(nullptr);
   }
+  g_is_shutdown = true;
 }
 
 static bool init_epoll1_linux();
@@ -1278,10 +1280,13 @@ const grpc_event_engine_vtable grpc_ev_epoll1_posix = {
 
     is_any_background_poller_thread,
     /* name = */ "epoll1",
-    /* check_engine_available = */ [](bool) { return init_epoll1_linux(); },
-    /* init_engine = */ []() {},
+    /* check_engine_available = */
+    [](bool) { return init_epoll1_linux(); },
+    /* init_engine = */
+    []() { GPR_ASSERT(init_epoll1_linux()); },
     shutdown_background_closure,
-    /* shutdown_engine = */ []() {},
+    /* shutdown_engine = */
+    []() { shutdown_engine(); },
     add_closure_to_background_poller,
 
     fd_set_pre_allocated,
@@ -1306,6 +1311,7 @@ static void reset_event_manager_on_fork() {
 // Create epoll_fd (epoll_set_init() takes care of that) to make sure epoll
 // support is available
 static bool init_epoll1_linux() {
+  if (!g_is_shutdown) return true;
   if (!grpc_has_wakeup_fd()) {
     gpr_log(GPR_ERROR, "Skipping epoll1 because of no wakeup fd.");
     return false;
@@ -1328,6 +1334,7 @@ static bool init_epoll1_linux() {
     grpc_core::Fork::SetResetChildPollingEngineFunc(
         reset_event_manager_on_fork);
   }
+  g_is_shutdown = false;
   return true;
 }
 

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

@@ -256,6 +256,15 @@ class EventEngineEndpointWrapper {
     }
   }
 
+  bool CanTrackErrors() {
+    if (EventEngineSupportsFd()) {
+      return reinterpret_cast<PosixEndpointWithFdSupport*>(endpoint_.get())
+          ->CanTrackErrors();
+    } else {
+      return false;
+    }
+  }
+
  private:
   void OnShutdownInternal() {
     {
@@ -378,7 +387,12 @@ int EndpointGetFd(grpc_endpoint* ep) {
   return eeep->wrapper->Fd();
 }
 
-bool EndpointCanTrackErr(grpc_endpoint* /* ep */) { return false; }
+bool EndpointCanTrackErr(grpc_endpoint* ep) {
+  auto* eeep =
+      reinterpret_cast<EventEngineEndpointWrapper::grpc_event_engine_endpoint*>(
+          ep);
+  return eeep->wrapper->CanTrackErrors();
+}
 
 grpc_endpoint_vtable grpc_event_engine_endpoint_vtable = {
     EndpointRead,