grpc 1.41.0 → 1.42.0

data/src/core/ext/filters/client_channel/subchannel_pool_interface.h

@@ -25,6 +25,7 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/iomgr/resolve_address.h"
 
 namespace grpc_core {
 
@@ -35,7 +36,8 @@ extern TraceFlag grpc_subchannel_pool_trace;
 // A key that can uniquely identify a subchannel.
 class SubchannelKey {
  public:
-  explicit SubchannelKey(const grpc_channel_args* args);
+  SubchannelKey(const grpc_resolved_address& address,
+                const grpc_channel_args* args);
   ~SubchannelKey();
 
   // Copyable.
@@ -47,13 +49,20 @@ class SubchannelKey {
 
   bool operator<(const SubchannelKey& other) const;
 
+  const grpc_resolved_address& address() const { return address_; }
+  const grpc_channel_args* args() const { return args_; }
+
+  // Human-readable string suitable for logging.
+  std::string ToString() const;
+
  private:
   // Initializes the subchannel key with the given \a args and the function to
   // copy channel args.
   void Init(
-      const grpc_channel_args* args,
+      const grpc_resolved_address& address, const grpc_channel_args* args,
       grpc_channel_args* (*copy_channel_args)(const grpc_channel_args* args));
 
+  grpc_resolved_address address_;
   const grpc_channel_args* args_;
 };
 

data/src/core/ext/filters/client_idle/client_idle_filter.cc

@@ -22,10 +22,11 @@
 
 #include <atomic>
 
+#include "src/core/ext/filters/client_idle/idle_filter_state.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
+#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/iomgr/timer.h"
-#include "src/core/lib/surface/channel_init.h"
 #include "src/core/lib/transport/http2_errors.h"
 
 // TODO(juanlishen): The idle filter is disabled in client channel by default
@@ -47,78 +48,8 @@ TraceFlag grpc_trace_client_idle_filter(false, "client_idle_filter");
 
 namespace {
 
-/*
-  client_idle_filter maintains a state tracking if there are active calls in the
-  channel and its internal idle_timer_. The states are specified as following:
-
-  +--------------------------------------------+-------------+---------+
-  |               ChannelState                 | idle_timer_ | channel |
-  +--------------------------------------------+-------------+---------+
-  | IDLE                                       | unset       | idle    |
-  | CALLS_ACTIVE                               | unset       | busy    |
-  | TIMER_PENDING                              | set-valid   | idle    |
-  | TIMER_PENDING_CALLS_ACTIVE                 | set-invalid | busy    |
-  | TIMER_PENDING_CALLS_SEEN_SINCE_TIMER_START | set-invalid | idle    |
-  +--------------------------------------------+-------------+---------+
-
-  IDLE: The initial state of the client_idle_filter, indicating the channel is
-  in IDLE.
-
-  CALLS_ACTIVE: The channel has 1 or 1+ active calls and the timer is not set.
-
-  TIMER_PENDING: The state after the timer is set and no calls have arrived
-  after the timer is set. The channel must have 0 active call in this state. If
-  the timer is fired in this state, the channel will go into IDLE state.
-
-  TIMER_PENDING_CALLS_ACTIVE: The state after the timer is set and at least one
-  call has arrived after the timer is set. The channel must have 1 or 1+ active
-  calls in this state. If the timer is fired in this state, we won't reschedule
-  it.
-
-  TIMER_PENDING_CALLS_SEEN_SINCE_TIMER_START: The state after the timer is set
-  and at least one call has arrived after the timer is set, BUT the channel
-  currently has 0 active call. If the timer is fired in this state, we will
-  reschedule it according to the finish time of the latest call.
-
-  PROCESSING: The state set to block other threads when the setting thread is
-  doing some work to keep state consistency.
-
-  idle_timer_ will not be cancelled (unless the channel is shutting down).
-  If the timer callback is called when the idle_timer_ is valid (i.e. idle_state
-  is TIMER_PENDING), the channel will enter IDLE, otherwise the channel won't be
-  changed.
-
-  State transitions:
-                                            IDLE
-                                            |  ^
-            ---------------------------------  *
-            |                                  *
-            v                                  *
-      CALLS_ACTIVE =================> TIMER_PENDING
-            ^                               |  ^
-            *  ------------------------------  *
-            *  |                               *
-            *  v                               *
-TIMER_PENDING_CALLS_ACTIVE ===> TIMER_PENDING_CALLS_SEEN_SINCE_TIMER_START
-            ^                               |
-            |                               |
-            ---------------------------------
-
-  ---> Triggered by IncreaseCallCount()
-  ===> Triggered by DecreaseCallCount()
-  ***> Triggered by IdleTimerCallback()
-*/
-enum ChannelState {
-  IDLE,
-  CALLS_ACTIVE,
-  TIMER_PENDING,
-  TIMER_PENDING_CALLS_ACTIVE,
-  TIMER_PENDING_CALLS_SEEN_SINCE_TIMER_START,
-  PROCESSING
-};
-
 grpc_millis GetClientIdleTimeout(const grpc_channel_args* args) {
-  return GPR_MAX(
+  return std::max(
       grpc_channel_arg_get_integer(
           grpc_channel_args_find(args, GRPC_ARG_CLIENT_IDLE_TIMEOUT_MS),
           {DEFAULT_IDLE_TIMEOUT_MS, 0, INT_MAX}),
@@ -159,9 +90,7 @@ class ChannelData {
   const grpc_millis client_idle_timeout_;
 
   // Member data used to track the state of channel.
-  grpc_millis last_idle_time_;
-  std::atomic<intptr_t> call_count_{0};
-  std::atomic<ChannelState> state_{IDLE};
+  IdleFilterState idle_filter_state_{false};
 
   // Idle timer and its callback closure.
   grpc_timer idle_timer_;
@@ -202,86 +131,13 @@ void ChannelData::StartTransportOp(grpc_channel_element* elem,
 }
 
 void ChannelData::IncreaseCallCount() {
-  const intptr_t previous_value =
-      call_count_.fetch_add(1, std::memory_order_relaxed);
-  GRPC_IDLE_FILTER_LOG("call counter has increased to %" PRIuPTR,
-                       previous_value + 1);
-  if (previous_value == 0) {
-    // This call is the one that makes the channel busy.
-    // Loop here to make sure the previous decrease operation has finished.
-    ChannelState state = state_.load(std::memory_order_relaxed);
-    while (true) {
-      switch (state) {
-        // Timer has not been set. Switch to CALLS_ACTIVE.
-        case IDLE:
-          // In this case, no other threads will modify the state, so we can
-          // just store the value.
-          state_.store(CALLS_ACTIVE, std::memory_order_relaxed);
-          return;
-        // Timer has been set. Switch to TIMER_PENDING_CALLS_ACTIVE.
-        case TIMER_PENDING:
-        case TIMER_PENDING_CALLS_SEEN_SINCE_TIMER_START:
-          // At this point, the state may have been switched to IDLE by the
-          // idle timer callback. Therefore, use CAS operation to change the
-          // state atomically.
-          // Use std::memory_order_acquire on success to ensure last_idle_time_
-          // has been properly set in DecreaseCallCount().
-          if (state_.compare_exchange_weak(state, TIMER_PENDING_CALLS_ACTIVE,
-                                           std::memory_order_acquire,
-                                           std::memory_order_relaxed)) {
-            return;
-          }
-          break;
-        default:
-          // The state has not been switched to desired value yet, try again.
-          state = state_.load(std::memory_order_relaxed);
-          break;
-      }
-    }
-  }
+  idle_filter_state_.IncreaseCallCount();
 }
 
 void ChannelData::DecreaseCallCount() {
-  const intptr_t previous_value =
-      call_count_.fetch_sub(1, std::memory_order_relaxed);
-  GRPC_IDLE_FILTER_LOG("call counter has decreased to %" PRIuPTR,
-                       previous_value - 1);
-  if (previous_value == 1) {
-    // This call is the one that makes the channel idle.
-    // last_idle_time_ does not need to be std::atomic<> because busy-loops in
-    // IncreaseCallCount(), DecreaseCallCount() and IdleTimerCallback() will
-    // prevent multiple threads from simultaneously accessing this variable.
-    last_idle_time_ = ExecCtx::Get()->Now();
-    ChannelState state = state_.load(std::memory_order_relaxed);
-    while (true) {
-      switch (state) {
-        // Timer has not been set. Set the timer and switch to TIMER_PENDING
-        case CALLS_ACTIVE:
-          // Release store here to make other threads see the updated value of
-          // last_idle_time_.
-          StartIdleTimer();
-          state_.store(TIMER_PENDING, std::memory_order_release);
-          return;
-        // Timer has been set. Switch to
-        // TIMER_PENDING_CALLS_SEEN_SINCE_TIMER_START
-        case TIMER_PENDING_CALLS_ACTIVE:
-          // At this point, the state may have been switched to CALLS_ACTIVE by
-          // the idle timer callback. Therefore, use CAS operation to change the
-          // state atomically.
-          // Release store here to make the idle timer callback see the updated
-          // value of last_idle_time_ to properly reset the idle timer.
-          if (state_.compare_exchange_weak(
-                  state, TIMER_PENDING_CALLS_SEEN_SINCE_TIMER_START,
-                  std::memory_order_release, std::memory_order_relaxed)) {
-            return;
-          }
-          break;
-        default:
-          // The state has not been switched to desired value yet, try again.
-          state = state_.load(std::memory_order_relaxed);
-          break;
-      }
-    }
+  if (idle_filter_state_.DecreaseCallCount()) {
+    // If there are no more calls in progress, start the idle timer.
+    StartIdleTimer();
   }
 }
 
@@ -315,44 +171,10 @@ void ChannelData::IdleTimerCallback(void* arg, grpc_error_handle error) {
     GRPC_CHANNEL_STACK_UNREF(chand->channel_stack_, "max idle timer callback");
     return;
   }
-  bool finished = false;
-  ChannelState state = chand->state_.load(std::memory_order_relaxed);
-  while (!finished) {
-    switch (state) {
-      case TIMER_PENDING:
-        // Change the state to PROCESSING to block IncreaseCallCout() until the
-        // EnterIdle() operation finishes, preventing mistakenly entering IDLE
-        // when active RPC exists.
-        finished = chand->state_.compare_exchange_weak(
-            state, PROCESSING, std::memory_order_acquire,
-            std::memory_order_relaxed);
-        if (finished) {
-          chand->EnterIdle();
-          chand->state_.store(IDLE, std::memory_order_relaxed);
-        }
-        break;
-      case TIMER_PENDING_CALLS_ACTIVE:
-        finished = chand->state_.compare_exchange_weak(
-            state, CALLS_ACTIVE, std::memory_order_relaxed,
-            std::memory_order_relaxed);
-        break;
-      case TIMER_PENDING_CALLS_SEEN_SINCE_TIMER_START:
-        // Change the state to PROCESSING to block IncreaseCallCount() until the
-        // StartIdleTimer() operation finishes, preventing mistakenly restarting
-        // the timer after grpc_timer_cancel() when shutdown.
-        finished = chand->state_.compare_exchange_weak(
-            state, PROCESSING, std::memory_order_acquire,
-            std::memory_order_relaxed);
-        if (finished) {
-          chand->StartIdleTimer();
-          chand->state_.store(TIMER_PENDING, std::memory_order_relaxed);
-        }
-        break;
-      default:
-        // The state has not been switched to desired value yet, try again.
-        state = chand->state_.load(std::memory_order_relaxed);
-        break;
-    }
+  if (chand->idle_filter_state_.CheckTimer()) {
+    chand->StartIdleTimer();
+  } else {
+    chand->EnterIdle();
   }
   GRPC_IDLE_FILTER_LOG("timer finishes");
   GRPC_CHANNEL_STACK_UNREF(chand->channel_stack_, "max idle timer callback");
@@ -368,7 +190,7 @@ void ChannelData::StartIdleTimer() {
   GRPC_IDLE_FILTER_LOG("timer has started");
   // Hold a ref to the channel stack for the timer callback.
   GRPC_CHANNEL_STACK_REF(channel_stack_, "max idle timer callback");
-  grpc_timer_init(&idle_timer_, last_idle_time_ + client_idle_timeout_,
+  grpc_timer_init(&idle_timer_, ExecCtx::Get()->Now() + client_idle_timeout_,
                   &idle_timer_callback_);
 }
 
@@ -422,26 +244,21 @@ const grpc_channel_filter grpc_client_idle_filter = {
     grpc_channel_next_get_info,
     "client_idle"};
 
-static bool MaybeAddClientIdleFilter(grpc_channel_stack_builder* builder,
-                                     void* /*arg*/) {
-  const grpc_channel_args* channel_args =
-      grpc_channel_stack_builder_get_channel_arguments(builder);
-  if (!grpc_channel_args_want_minimal_stack(channel_args) &&
-      GetClientIdleTimeout(channel_args) != INT_MAX) {
-    return grpc_channel_stack_builder_prepend_filter(
-        builder, &grpc_client_idle_filter, nullptr, nullptr);
-  } else {
-    return true;
-  }
-}
-
 }  // namespace
-}  // namespace grpc_core
 
-void grpc_client_idle_filter_init(void) {
-  grpc_channel_init_register_stage(
+void RegisterClientIdleFilter(CoreConfiguration::Builder* builder) {
+  builder->channel_init()->RegisterStage(
       GRPC_CLIENT_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-      grpc_core::MaybeAddClientIdleFilter, nullptr);
+      [](grpc_channel_stack_builder* builder) {
+        const grpc_channel_args* channel_args =
+            grpc_channel_stack_builder_get_channel_arguments(builder);
+        if (!grpc_channel_args_want_minimal_stack(channel_args) &&
+            GetClientIdleTimeout(channel_args) != INT_MAX) {
+          return grpc_channel_stack_builder_prepend_filter(
+              builder, &grpc_client_idle_filter, nullptr, nullptr);
+        } else {
+          return true;
+        }
+      });
 }
-
-void grpc_client_idle_filter_shutdown(void) {}
+}  // namespace grpc_core

data/src/core/ext/filters/client_idle/idle_filter_state.cc

@@ -0,0 +1,96 @@
+// Copyright 2021 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/ext/filters/client_idle/idle_filter_state.h"
+
+#include <assert.h>
+
+namespace grpc_core {
+
+IdleFilterState::IdleFilterState(bool start_timer)
+    : state_(start_timer ? kTimerStarted : 0) {}
+
+void IdleFilterState::IncreaseCallCount() {
+  uintptr_t state = state_.load(std::memory_order_relaxed);
+  uintptr_t new_state;
+  do {
+    // Increment the counter, and flag that there's been activity.
+    new_state = state;
+    new_state |= kCallsStartedSinceLastTimerCheck;
+    new_state += kCallIncrement;
+  } while (!state_.compare_exchange_weak(
+      state, new_state, std::memory_order_acq_rel, std::memory_order_relaxed));
+}
+
+bool IdleFilterState::DecreaseCallCount() {
+  uintptr_t state = state_.load(std::memory_order_relaxed);
+  uintptr_t new_state;
+  bool start_timer;
+  do {
+    start_timer = false;
+    new_state = state;
+    // Decrement call count (and assert there's at least one call outstanding!)
+    assert(new_state >= kCallIncrement);
+    new_state -= kCallIncrement;
+    // If that decrement reaches a call count of zero and we have not started a
+    // timer
+    if ((new_state >> kCallsInProgressShift) == 0 &&
+        (new_state & kTimerStarted) == 0) {
+      // Flag that we will start a timer, and mark it started so nobody else
+      // does.
+      start_timer = true;
+      new_state |= kTimerStarted;
+      new_state &= ~kCallsInProgressShift;
+    }
+  } while (!state_.compare_exchange_weak(
+      state, new_state, std::memory_order_acq_rel, std::memory_order_relaxed));
+  return start_timer;
+}
+
+bool IdleFilterState::CheckTimer() {
+  uintptr_t state = state_.load(std::memory_order_relaxed);
+  uintptr_t new_state;
+  bool start_timer;
+  do {
+    if ((state >> kCallsInProgressShift) != 0) {
+      // Still calls in progress: nothing needs updating, just return
+      // and keep the timer going!
+      return true;
+    }
+    new_state = state;
+    bool is_active = false;
+    if (new_state & kCallsStartedSinceLastTimerCheck) {
+      // If any calls started since the last time we checked, then consider the
+      // channel still active and try again.
+      is_active = true;
+      new_state &= ~kCallsStartedSinceLastTimerCheck;
+    }
+    if (is_active) {
+      // If we are still active, we should signal that the timer should start
+      // again.
+      start_timer = true;
+    } else {
+      // Otherwise, we should not start the timer again, and we should signal
+      // that in the updated state.
+      start_timer = false;
+      new_state &= ~kTimerStarted;
+    }
+  } while (!state_.compare_exchange_weak(
+      state, new_state, std::memory_order_acq_rel, std::memory_order_relaxed));
+  return start_timer;
+}
+
+}  // namespace grpc_core

data/src/core/ext/filters/client_idle/idle_filter_state.h

@@ -0,0 +1,66 @@
+// Copyright 2021 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_CORE_EXT_FILTERS_CLIENT_IDLE_IDLE_FILTER_STATE_H
+#define GRPC_CORE_EXT_FILTERS_CLIENT_IDLE_IDLE_FILTER_STATE_H
+
+#include <grpc/support/port_platform.h>
+
+#include <atomic>
+
+namespace grpc_core {
+
+// State machine for the idle filter.
+// Keeps track of how many calls are in progress, whether there is a timer
+// started, and whether we've seen calls since the previous timer fired.
+class IdleFilterState {
+ public:
+  explicit IdleFilterState(bool start_timer);
+  ~IdleFilterState() = default;
+
+  IdleFilterState(const IdleFilterState&);
+  IdleFilterState& operator=(const IdleFilterState&);
+
+  // Increment the number of calls in progress.
+  void IncreaseCallCount();
+
+  // Decrement the number of calls in progress.
+  // Return true if we reached idle with no timer started.
+  GRPC_MUST_USE_RESULT bool DecreaseCallCount();
+
+  // Check if there's been any activity since the last timer check.
+  // If there was, reset the activity flag and return true to indicated that
+  // a new timer should be started.
+  // If there was not, reset the timer flag and return false - in this case
+  // we know that the channel is idle and has been for one full cycle.
+  GRPC_MUST_USE_RESULT bool CheckTimer();
+
+ private:
+  // Bit in state_ indicating that the timer has been started.
+  static constexpr uintptr_t kTimerStarted = 1;
+  // Bit in state_ indicating that we've seen a call start or stop since the
+  // last timer.
+  static constexpr uintptr_t kCallsStartedSinceLastTimerCheck = 2;
+  // How much should we shift to get the number of calls in progress.
+  static constexpr uintptr_t kCallsInProgressShift = 2;
+  // How much to increment/decrement the state_ when a call is started/stopped.
+  // Ensures we don't clobber the preceding bits.
+  static constexpr uintptr_t kCallIncrement = uintptr_t(1)
+                                              << kCallsInProgressShift;
+  std::atomic<uintptr_t> state_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_IDLE_IDLE_FILTER_STATE_H

data/src/core/ext/filters/deadline/deadline_filter.cc

@@ -27,10 +27,10 @@
 #include <grpc/support/time.h>
 
 #include "src/core/lib/channel/channel_stack_builder.h"
+#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/surface/channel_init.h"
 
 namespace grpc_core {
 
@@ -114,9 +114,7 @@ class TimerState {
 // synchronized.
 static void start_timer_if_needed(grpc_call_element* elem,
                                   grpc_millis deadline) {
-  if (deadline == GRPC_MILLIS_INF_FUTURE) {
-    return;
-  }
+  if (deadline == GRPC_MILLIS_INF_FUTURE) return;
   grpc_deadline_state* deadline_state =
       static_cast<grpc_deadline_state*>(elem->call_data);
   GPR_ASSERT(deadline_state->timer_state == nullptr);
@@ -295,7 +293,9 @@ static void deadline_client_start_transport_stream_op_batch(
 static void recv_initial_metadata_ready(void* arg, grpc_error_handle error) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(arg);
   server_call_data* calld = static_cast<server_call_data*>(elem->call_data);
-  start_timer_if_needed(elem, calld->recv_initial_metadata->deadline);
+  start_timer_if_needed(
+      elem, calld->recv_initial_metadata->get(grpc_core::GrpcTimeoutMetadata())
+                .value_or(GRPC_MILLIS_INF_FUTURE));
   // Invoke the next callback.
   grpc_core::Closure::Run(DEBUG_LOCATION,
                           calld->next_recv_initial_metadata_ready,
@@ -370,25 +370,22 @@ bool grpc_deadline_checking_enabled(const grpc_channel_args* channel_args) {
       !grpc_channel_args_want_minimal_stack(channel_args));
 }
 
-static bool maybe_add_deadline_filter(grpc_channel_stack_builder* builder,
-                                      void* arg) {
-  return grpc_deadline_checking_enabled(
-             grpc_channel_stack_builder_get_channel_arguments(builder))
-             ? grpc_channel_stack_builder_prepend_filter(
-                   builder, static_cast<const grpc_channel_filter*>(arg),
-                   nullptr, nullptr)
-             : true;
-}
-
-void grpc_deadline_filter_init(void) {
-  grpc_channel_init_register_stage(
-      GRPC_CLIENT_DIRECT_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-      maybe_add_deadline_filter,
-      const_cast<grpc_channel_filter*>(&grpc_client_deadline_filter));
-  grpc_channel_init_register_stage(
-      GRPC_SERVER_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-      maybe_add_deadline_filter,
-      const_cast<grpc_channel_filter*>(&grpc_server_deadline_filter));
+namespace grpc_core {
+void RegisterDeadlineFilter(CoreConfiguration::Builder* builder) {
+  auto register_filter = [builder](grpc_channel_stack_type type,
+                                   const grpc_channel_filter* filter) {
+    builder->channel_init()->RegisterStage(
+        type, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
+        [filter](grpc_channel_stack_builder* builder) {
+          if (grpc_deadline_checking_enabled(
+                  grpc_channel_stack_builder_get_channel_arguments(builder))) {
+            return grpc_channel_stack_builder_prepend_filter(builder, filter,
+                                                             nullptr, nullptr);
+          }
+          return true;
+        });
+  };
+  register_filter(GRPC_CLIENT_DIRECT_CHANNEL, &grpc_client_deadline_filter);
+  register_filter(GRPC_SERVER_CHANNEL, &grpc_server_deadline_filter);
 }
-
-void grpc_deadline_filter_shutdown(void) {}
+}  // namespace grpc_core

data/src/core/ext/filters/fault_injection/fault_injection_filter.cc

@@ -25,9 +25,8 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include "src/core/ext/filters/client_channel/service_config.h"
-#include "src/core/ext/filters/client_channel/service_config_call_data.h"
 #include "src/core/ext/filters/fault_injection/service_config_parser.h"
+#include "src/core/ext/service_config/service_config_call_data.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -46,27 +45,27 @@ static_assert(
     std::is_trivially_destructible<std::atomic<uint32_t>>::value,
     "the active fault counter needs to have a trivially destructible type");
 
-inline int GetLinkedMetadatumValueInt(grpc_linked_mdelem* md) {
+inline int GetMetadatumValueInt(grpc_mdelem md) {
   int res;
-  if (absl::SimpleAtoi(StringViewFromSlice(GRPC_MDVALUE(md->md)), &res)) {
+  if (absl::SimpleAtoi(StringViewFromSlice(GRPC_MDVALUE(md)), &res)) {
     return res;
   } else {
     return -1;
   }
 }
 
-inline uint32_t GetLinkedMetadatumValueUnsignedInt(grpc_linked_mdelem* md) {
+inline uint32_t GetMetadatumValueUnsignedInt(grpc_mdelem md) {
   uint32_t res;
-  if (absl::SimpleAtoi(StringViewFromSlice(GRPC_MDVALUE(md->md)), &res)) {
+  if (absl::SimpleAtoi(StringViewFromSlice(GRPC_MDVALUE(md)), &res)) {
     return res;
   } else {
     return -1;
   }
 }
 
-inline int64_t GetLinkedMetadatumValueInt64(grpc_linked_mdelem* md) {
+inline int64_t GetMetadatumValueInt64(grpc_mdelem md) {
   int64_t res;
-  if (absl::SimpleAtoi(StringViewFromSlice(GRPC_MDVALUE(md->md)), &res)) {
+  if (absl::SimpleAtoi(StringViewFromSlice(GRPC_MDVALUE(md)), &res)) {
     return res;
   } else {
     return -1;
@@ -347,9 +346,8 @@ void CallData::DecideWhetherToInjectFaults(
                 *fi_policy_);
       }
     };
-    for (grpc_linked_mdelem* md = initial_metadata->list.head; md != nullptr;
-         md = md->next) {
-      absl::string_view key = StringViewFromSlice(GRPC_MDKEY(md->md));
+    initial_metadata->ForEach([&](grpc_mdelem md) {
+      absl::string_view key = StringViewFromSlice(GRPC_MDKEY(md));
       // Only perform string comparison if:
       //   1. Needs to check this header;
       //   2. The value is not been filled before.
@@ -358,31 +356,31 @@ void CallData::DecideWhetherToInjectFaults(
            copied_policy->abort_code == GRPC_STATUS_OK) &&
           key == fi_policy_->abort_code_header) {
         maybe_copy_policy_func();
-        grpc_status_code_from_int(GetLinkedMetadatumValueInt(md),
+        grpc_status_code_from_int(GetMetadatumValueInt(md),
                                   &copied_policy->abort_code);
       }
       if (!fi_policy_->abort_percentage_header.empty() &&
           key == fi_policy_->abort_percentage_header) {
         maybe_copy_policy_func();
         copied_policy->abort_percentage_numerator =
-            GPR_MIN(GetLinkedMetadatumValueUnsignedInt(md),
-                    fi_policy_->abort_percentage_numerator);
+            std::min(GetMetadatumValueUnsignedInt(md),
+                     fi_policy_->abort_percentage_numerator);
       }
       if (!fi_policy_->delay_header.empty() &&
           (copied_policy == nullptr || copied_policy->delay == 0) &&
           key == fi_policy_->delay_header) {
         maybe_copy_policy_func();
         copied_policy->delay = static_cast<grpc_millis>(
-            GPR_MAX(GetLinkedMetadatumValueInt64(md), 0));
+            std::max(GetMetadatumValueInt64(md), int64_t(0)));
       }
       if (!fi_policy_->delay_percentage_header.empty() &&
           key == fi_policy_->delay_percentage_header) {
         maybe_copy_policy_func();
         copied_policy->delay_percentage_numerator =
-            GPR_MIN(GetLinkedMetadatumValueUnsignedInt(md),
-                    fi_policy_->delay_percentage_numerator);
+            std::min(GetMetadatumValueUnsignedInt(md),
+                     fi_policy_->delay_percentage_numerator);
       }
-    }
+    });
     if (copied_policy != nullptr) fi_policy_ = copied_policy;
   }
   // Roll the dice
@@ -456,8 +454,10 @@ void CallData::ResumeBatch(void* arg, grpc_error_handle error) {
   // Abort if needed.
   error = calld->MaybeAbort();
   if (error != GRPC_ERROR_NONE) {
+    calld->abort_error_ = error;
     grpc_transport_stream_op_batch_finish_with_failure(
-        calld->delayed_batch_, error, calld->call_combiner_);
+        calld->delayed_batch_, GRPC_ERROR_REF(calld->abort_error_),
+        calld->call_combiner_);
     return;
   }
   // Chain to the next filter.