grpc 1.23.0 → 1.24.0

data/src/core/ext/filters/client_channel/lb_policy/xds/xds_load_balancer_api.h

@@ -23,67 +23,105 @@
 
 #include <grpc/slice_buffer.h>
 
-#include "src/core/ext/filters/client_channel/lb_policy/grpclb/proto/grpc/lb/v1/load_balancer.pb.h"
 #include "src/core/ext/filters/client_channel/lb_policy/xds/xds_client_stats.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
-
-#define XDS_SERVICE_NAME_MAX_LENGTH 128
-
-typedef grpc_lb_v1_Server_ip_address_t xds_grpclb_ip_address;
-typedef grpc_lb_v1_LoadBalanceRequest xds_grpclb_request;
-typedef grpc_lb_v1_InitialLoadBalanceResponse xds_grpclb_initial_response;
-typedef grpc_lb_v1_Server xds_grpclb_server;
-typedef google_protobuf_Duration xds_grpclb_duration;
-typedef google_protobuf_Timestamp xds_grpclb_timestamp;
-
-typedef struct {
-  xds_grpclb_server** servers;
-  size_t num_servers;
-} xds_grpclb_serverlist;
-
-/** Create a request for a gRPC LB service under \a lb_service_name */
-xds_grpclb_request* xds_grpclb_request_create(const char* lb_service_name);
-xds_grpclb_request* xds_grpclb_load_report_request_create_locked(
-    grpc_core::XdsLbClientStats* client_stats);
-
-/** Protocol Buffers v3-encode \a request */
-grpc_slice xds_grpclb_request_encode(const xds_grpclb_request* request);
-
-/** Destroy \a request */
-void xds_grpclb_request_destroy(xds_grpclb_request* request);
-
-/** Parse (ie, decode) the bytes in \a encoded_xds_grpclb_response as a \a
- * xds_grpclb_initial_response */
-xds_grpclb_initial_response* xds_grpclb_initial_response_parse(
-    const grpc_slice& encoded_xds_grpclb_response);
-
-/** Parse the list of servers from an encoded \a xds_grpclb_response */
-xds_grpclb_serverlist* xds_grpclb_response_parse_serverlist(
-    const grpc_slice& encoded_xds_grpclb_response);
-
-/** Return a copy of \a sl. The caller is responsible for calling \a
- * xds_grpclb_destroy_serverlist on the returned copy. */
-xds_grpclb_serverlist* xds_grpclb_serverlist_copy(
-    const xds_grpclb_serverlist* sl);
-
-bool xds_grpclb_serverlist_equals(const xds_grpclb_serverlist* lhs,
-                                  const xds_grpclb_serverlist* rhs);
-
-bool xds_grpclb_server_equals(const xds_grpclb_server* lhs,
-                              const xds_grpclb_server* rhs);
-
-/** Destroy \a serverlist */
-void xds_grpclb_destroy_serverlist(xds_grpclb_serverlist* serverlist);
-
-/** Compare \a lhs against \a rhs and return 0 if \a lhs and \a rhs are equal,
- * < 0 if \a lhs represents a duration shorter than \a rhs and > 0 otherwise */
-int xds_grpclb_duration_compare(const xds_grpclb_duration* lhs,
-                                const xds_grpclb_duration* rhs);
-
-grpc_millis xds_grpclb_duration_to_millis(xds_grpclb_duration* duration_pb);
-
-/** Destroy \a initial_response */
-void xds_grpclb_initial_response_destroy(xds_grpclb_initial_response* response);
+#include "src/core/ext/filters/client_channel/server_address.h"
+
+namespace grpc_core {
+
+struct XdsLocalityInfo {
+  bool operator==(const XdsLocalityInfo& other) const {
+    return *locality_name == *other.locality_name &&
+           serverlist == other.serverlist && lb_weight == other.lb_weight &&
+           priority == other.priority;
+  }
+
+  // This comparator only compares the locality names.
+  struct Less {
+    bool operator()(const XdsLocalityInfo& lhs,
+                    const XdsLocalityInfo& rhs) const {
+      return XdsLocalityName::Less()(lhs.locality_name, rhs.locality_name);
+    }
+  };
+
+  RefCountedPtr<XdsLocalityName> locality_name;
+  ServerAddressList serverlist;
+  uint32_t lb_weight;
+  uint32_t priority;
+};
+
+using XdsLocalityList = InlinedVector<XdsLocalityInfo, 1>;
+
+// There are two phases of accessing this class's content:
+// 1. to initialize in the control plane combiner;
+// 2. to use in the data plane combiner.
+// So no additional synchronization is needed.
+class XdsDropConfig : public RefCounted<XdsDropConfig> {
+ public:
+  struct DropCategory {
+    bool operator==(const DropCategory& other) const {
+      return strcmp(name.get(), other.name.get()) == 0 &&
+             parts_per_million == other.parts_per_million;
+    }
+
+    UniquePtr<char> name;
+    const uint32_t parts_per_million;
+  };
+
+  using DropCategoryList = InlinedVector<DropCategory, 2>;
+
+  void AddCategory(UniquePtr<char> name, uint32_t parts_per_million) {
+    drop_category_list_.emplace_back(
+        DropCategory{std::move(name), parts_per_million});
+  }
+
+  // The only method invoked from the data plane combiner.
+  bool ShouldDrop(const UniquePtr<char>** category_name) const;
+
+  const DropCategoryList& drop_category_list() const {
+    return drop_category_list_;
+  }
+
+  bool operator==(const XdsDropConfig& other) const {
+    return drop_category_list_ == other.drop_category_list_;
+  }
+  bool operator!=(const XdsDropConfig& other) const {
+    return !(*this == other);
+  }
+
+ private:
+  DropCategoryList drop_category_list_;
+};
+
+struct XdsUpdate {
+  XdsLocalityList locality_list;
+  RefCountedPtr<XdsDropConfig> drop_config;
+  bool drop_all = false;
+};
+
+// Creates an EDS request querying \a service_name.
+grpc_slice XdsEdsRequestCreateAndEncode(const char* service_name);
+
+// Parses the EDS response and returns the args to update locality map. If there
+// is any error, the output update is invalid.
+grpc_error* XdsEdsResponseDecodeAndParse(const grpc_slice& encoded_response,
+                                         XdsUpdate* update);
+
+// Creates an LRS request querying \a server_name.
+grpc_slice XdsLrsRequestCreateAndEncode(const char* server_name);
+
+// Creates an LRS request sending client-side load reports. If all the counters
+// in \a client_stats are zero, returns empty slice.
+grpc_slice XdsLrsRequestCreateAndEncode(const char* server_name,
+                                        XdsClientStats* client_stats);
+
+// Parses the LRS response and returns the client-side load reporting interval.
+// If there is any error (e.g., the found server name doesn't match \a
+// expected_server_name), the output config is invalid.
+grpc_error* XdsLrsResponseDecodeAndParse(const grpc_slice& encoded_response,
+                                         grpc_millis* load_reporting_interval,
+                                         const char* expected_server_name);
+
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_XDS_XDS_LOAD_BALANCER_API_H \
         */

data/src/core/ext/filters/client_channel/lb_policy_registry.cc

@@ -117,8 +117,13 @@ namespace {
 grpc_json* ParseLoadBalancingConfigHelper(const grpc_json* lb_config_array,
                                           grpc_error** error) {
   GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
+  if (lb_config_array == nullptr) {
+    *error =
+        GRPC_ERROR_CREATE_FROM_STATIC_STRING("LB config JSON tree is null");
+    return nullptr;
+  }
   char* error_msg;
-  if (lb_config_array == nullptr || lb_config_array->type != GRPC_JSON_ARRAY) {
+  if (lb_config_array->type != GRPC_JSON_ARRAY) {
     gpr_asprintf(&error_msg, "field:%s error:type should be array",
                  lb_config_array->key);
     *error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(error_msg);

data/src/core/ext/filters/client_channel/resolver/xds/xds_resolver.cc

@@ -0,0 +1,89 @@
+/*
+ *
+ * Copyright 2019 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_channel/resolver_registry.h"
+
+namespace grpc_core {
+
+namespace {
+
+class XdsResolver : public Resolver {
+ public:
+  explicit XdsResolver(ResolverArgs args)
+      : Resolver(args.combiner, std::move(args.result_handler)),
+        args_(grpc_channel_args_copy(args.args)) {}
+  ~XdsResolver() override { grpc_channel_args_destroy(args_); }
+
+  void StartLocked() override;
+
+  void ShutdownLocked() override{};
+
+ private:
+  const grpc_channel_args* args_;
+};
+
+void XdsResolver::StartLocked() {
+  static const char* service_config =
+      "{\n"
+      "  \"loadBalancingConfig\":[\n"
+      "    { \"xds_experimental\":{} }\n"
+      "  ]\n"
+      "}";
+  Result result;
+  result.args = args_;
+  args_ = nullptr;
+  grpc_error* error = GRPC_ERROR_NONE;
+  result.service_config = ServiceConfig::Create(service_config, &error);
+  result_handler()->ReturnResult(std::move(result));
+}
+
+//
+// Factory
+//
+
+class XdsResolverFactory : public ResolverFactory {
+ public:
+  bool IsValidUri(const grpc_uri* uri) const override {
+    if (GPR_UNLIKELY(0 != strcmp(uri->authority, ""))) {
+      gpr_log(GPR_ERROR, "URI authority not supported");
+      return false;
+    }
+    return true;
+  }
+
+  OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
+    if (!IsValidUri(args.uri)) return nullptr;
+    return OrphanablePtr<Resolver>(New<XdsResolver>(std::move(args)));
+  }
+
+  const char* scheme() const override { return "xds-experimental"; }
+};
+
+}  // namespace
+
+}  // namespace grpc_core
+
+void grpc_resolver_xds_init() {
+  grpc_core::ResolverRegistry::Builder::RegisterResolverFactory(
+      grpc_core::UniquePtr<grpc_core::ResolverFactory>(
+          grpc_core::New<grpc_core::XdsResolverFactory>()));
+}
+
+void grpc_resolver_xds_shutdown() {}

data/src/core/ext/filters/client_channel/resolving_lb_policy.cc

@@ -113,13 +113,6 @@ class ResolvingLoadBalancingPolicy::ResolvingControlHelper
     return parent_->channel_control_helper()->CreateSubchannel(args);
   }
 
-  grpc_channel* CreateChannel(const char* target,
-                              const grpc_channel_args& args) override {
-    if (parent_->resolver_ == nullptr) return nullptr;  // Shutting down.
-    if (!CalledByCurrentChild() && !CalledByPendingChild()) return nullptr;
-    return parent_->channel_control_helper()->CreateChannel(target, args);
-  }
-
   void UpdateState(grpc_connectivity_state state,
                    UniquePtr<SubchannelPicker> picker) override {
     if (parent_->resolver_ == nullptr) return;  // Shutting down.
@@ -160,6 +153,8 @@ class ResolvingLoadBalancingPolicy::ResolvingControlHelper
     }
   }
 
+  void AddTraceEvent(TraceSeverity severity, StringView message) override {}
+
   void set_child(LoadBalancingPolicy* child) { child_ = child; }
 
  private:
@@ -433,7 +428,7 @@ void ResolvingLoadBalancingPolicy::ConcatenateAndAddChannelTraceLocked(
     size_t len = 0;
     UniquePtr<char> message(gpr_strvec_flatten(&v, &len));
     channel_control_helper()->AddTraceEvent(ChannelControlHelper::TRACE_INFO,
-                                            message.get());
+                                            StringView(message.get()));
     gpr_strvec_destroy(&v);
   }
 }

data/src/core/ext/filters/client_channel/server_address.cc

@@ -20,8 +20,6 @@
 
 #include "src/core/ext/filters/client_channel/server_address.h"
 
-#include <string.h>
-
 namespace grpc_core {
 
 //
@@ -39,7 +37,7 @@ ServerAddress::ServerAddress(const void* address, size_t address_len,
   address_.len = static_cast<socklen_t>(address_len);
 }
 
-bool ServerAddress::operator==(const grpc_core::ServerAddress& other) const {
+bool ServerAddress::operator==(const ServerAddress& other) const {
   return address_.len == other.address_.len &&
          memcmp(address_.addr, other.address_.addr, address_.len) == 0 &&
          grpc_channel_args_compare(args_, other.args_) == 0;

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

@@ -24,7 +24,6 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/inlined_vector.h"
 #include "src/core/lib/iomgr/resolve_address.h"
-#include "src/core/lib/uri/uri_parser.h"
 
 // Channel arg key for a bool indicating whether an address is a grpclb
 // load balancer (as opposed to a backend).
@@ -68,6 +67,7 @@ class ServerAddress {
   }
   ServerAddress& operator=(ServerAddress&& other) {
     address_ = other.address_;
+    grpc_channel_args_destroy(args_);
     args_ = other.args_;
     other.args_ = nullptr;
     return *this;

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

@@ -26,6 +26,7 @@
 #include "src/core/ext/filters/client_channel/subchannel_pool_interface.h"
 #include "src/core/lib/backoff/backoff.h"
 #include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/gpr/time_precise.h"
 #include "src/core/lib/gprpp/arena.h"
 #include "src/core/lib/gprpp/map.h"
 #include "src/core/lib/gprpp/ref_counted.h"
@@ -104,7 +105,7 @@ class SubchannelCall {
     RefCountedPtr<ConnectedSubchannel> connected_subchannel;
     grpc_polling_entity* pollent;
     grpc_slice path;
-    gpr_timespec start_time;
+    gpr_cycle_counter start_time;
     grpc_millis deadline;
     Arena* arena;
     grpc_call_context_element* context;

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

@@ -27,12 +27,12 @@
 #include "src/core/lib/surface/channel_init.h"
 #include "src/core/lib/transport/http2_errors.h"
 
-// The idle filter is disabled in client channel by default.
-// To enable the idle filte, set GRPC_ARG_CLIENT_IDLE_TIMEOUT_MS to [0, INT_MAX)
-// in channel args.
-// TODO(qianchengz): Find a reasonable default value. Maybe check what deault
-// value Java uses.
-#define DEFAULT_IDLE_TIMEOUT_MS INT_MAX
+// The idle filter is enabled in client channel by default.
+// Set GRPC_ARG_CLIENT_IDLE_TIMEOUT_MS to [1000, INT_MAX) in channel args to
+// configure the idle timeout.
+#define DEFAULT_IDLE_TIMEOUT_MS (30 /*minutes*/ * 60 * 1000)
+// The user input idle timeout smaller than this would be capped to it.
+#define MIN_IDLE_TIMEOUT_MS (1 /*second*/ * 1000)
 
 namespace grpc_core {
 
@@ -47,10 +47,82 @@ 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 grpc_channel_arg_get_integer(
-      grpc_channel_args_find(args, GRPC_ARG_CLIENT_IDLE_TIMEOUT_MS),
-      {DEFAULT_IDLE_TIMEOUT_MS, 0, INT_MAX});
+  return GPR_MAX(
+      grpc_channel_arg_get_integer(
+          grpc_channel_args_find(args, GRPC_ARG_CLIENT_IDLE_TIMEOUT_MS),
+          {DEFAULT_IDLE_TIMEOUT_MS, 0, INT_MAX}),
+      MIN_IDLE_TIMEOUT_MS);
 }
 
 class ChannelData {
@@ -86,8 +158,9 @@ class ChannelData {
   const grpc_millis client_idle_timeout_;
 
   // Member data used to track the state of channel.
-  Mutex call_count_mu_;
-  size_t call_count_;
+  grpc_millis last_idle_time_;
+  Atomic<intptr_t> call_count_{0};
+  Atomic<ChannelState> state_{IDLE};
 
   // Idle timer and its callback closure.
   grpc_timer idle_timer_;
@@ -115,37 +188,105 @@ void ChannelData::StartTransportOp(grpc_channel_element* elem,
   ChannelData* chand = static_cast<ChannelData*>(elem->channel_data);
   // Catch the disconnect_with_error transport op.
   if (op->disconnect_with_error != nullptr) {
-    // Disconnect. Cancel the timer if we set it before.
-    // IncreaseCallCount() introduces a dummy call. It will cancel the timer and
-    // prevent the timer from being reset by other threads.
+    // IncreaseCallCount() introduces a dummy call and prevent the timer from
+    // being reset by other threads.
     chand->IncreaseCallCount();
+    // If the timer has been set, cancel the timer.
+    // No synchronization issues here. grpc_timer_cancel() is valid as long as
+    // the timer has been init()ed before.
+    grpc_timer_cancel(&chand->idle_timer_);
   }
   // Pass the op to the next filter.
   grpc_channel_next_op(elem, op);
 }
 
 void ChannelData::IncreaseCallCount() {
-  MutexLock lock(&call_count_mu_);
-  if (call_count_++ == 0) {
-    grpc_timer_cancel(&idle_timer_);
+  const intptr_t previous_value = call_count_.FetchAdd(1, MemoryOrder::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(MemoryOrder::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, MemoryOrder::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 MemoryOrder::ACQUIRE on success to ensure last_idle_time_ has
+          // been properly set in DecreaseCallCount().
+          if (state_.CompareExchangeWeak(&state, TIMER_PENDING_CALLS_ACTIVE,
+                                         MemoryOrder::ACQUIRE,
+                                         MemoryOrder::RELAXED)) {
+            return;
+          }
+          break;
+        default:
+          // The state has not been switched to desired value yet, try again.
+          state = state_.Load(MemoryOrder::RELAXED);
+          break;
+      }
+    }
   }
-  GRPC_IDLE_FILTER_LOG("call counter has increased to %" PRIuPTR, call_count_);
 }
 
 void ChannelData::DecreaseCallCount() {
-  MutexLock lock(&call_count_mu_);
-  if (call_count_-- == 1) {
-    StartIdleTimer();
+  const intptr_t previous_value = call_count_.FetchSub(1, MemoryOrder::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 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(MemoryOrder::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, MemoryOrder::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_.CompareExchangeWeak(
+                  &state, TIMER_PENDING_CALLS_SEEN_SINCE_TIMER_START,
+                  MemoryOrder::RELEASE, MemoryOrder::RELAXED)) {
+            return;
+          }
+          break;
+        default:
+          // The state has not been switched to desired value yet, try again.
+          state = state_.Load(MemoryOrder::RELAXED);
+          break;
+      }
+    }
   }
-  GRPC_IDLE_FILTER_LOG("call counter has decreased to %" PRIuPTR, call_count_);
 }
 
 ChannelData::ChannelData(grpc_channel_element* elem,
                          grpc_channel_element_args* args, grpc_error** error)
     : elem_(elem),
       channel_stack_(args->channel_stack),
-      client_idle_timeout_(GetClientIdleTimeout(args->channel_args)),
-      call_count_(0) {
+      client_idle_timeout_(GetClientIdleTimeout(args->channel_args)) {
   // If the idle filter is explicitly disabled in channel args, this ctor should
   // not get called.
   GPR_ASSERT(client_idle_timeout_ != GRPC_MILLIS_INF_FUTURE);
@@ -165,10 +306,45 @@ ChannelData::ChannelData(grpc_channel_element* elem,
 void ChannelData::IdleTimerCallback(void* arg, grpc_error* error) {
   GRPC_IDLE_FILTER_LOG("timer alarms");
   ChannelData* chand = static_cast<ChannelData*>(arg);
-  {
-    MutexLock lock(&chand->call_count_mu_);
-    if (error == GRPC_ERROR_NONE && chand->call_count_ == 0) {
-      chand->EnterIdle();
+  if (error != GRPC_ERROR_NONE) {
+    GRPC_IDLE_FILTER_LOG("timer canceled");
+    GRPC_CHANNEL_STACK_UNREF(chand->channel_stack_, "max idle timer callback");
+    return;
+  }
+  bool finished = false;
+  ChannelState state = chand->state_.Load(MemoryOrder::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_.CompareExchangeWeak(
+            &state, PROCESSING, MemoryOrder::ACQUIRE, MemoryOrder::RELAXED);
+        if (finished) {
+          chand->EnterIdle();
+          chand->state_.Store(IDLE, MemoryOrder::RELAXED);
+        }
+        break;
+      case TIMER_PENDING_CALLS_ACTIVE:
+        finished = chand->state_.CompareExchangeWeak(
+            &state, CALLS_ACTIVE, MemoryOrder::RELAXED, MemoryOrder::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_.CompareExchangeWeak(
+            &state, PROCESSING, MemoryOrder::ACQUIRE, MemoryOrder::RELAXED);
+        if (finished) {
+          chand->StartIdleTimer();
+          chand->state_.Store(TIMER_PENDING, MemoryOrder::RELAXED);
+        }
+        break;
+      default:
+        // The state has not been switched to desired value yet, try again.
+        state = chand->state_.Load(MemoryOrder::RELAXED);
+        break;
     }
   }
   GRPC_IDLE_FILTER_LOG("timer finishes");
@@ -185,7 +361,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_, ExecCtx::Get()->Now() + client_idle_timeout_,
+  grpc_timer_init(&idle_timer_, last_idle_time_ + client_idle_timeout_,
                   &idle_timer_callback_);
 }
 
@@ -193,6 +369,8 @@ void ChannelData::EnterIdle() {
   GRPC_IDLE_FILTER_LOG("the channel will enter IDLE");
   // Hold a ref to the channel stack for the transport op.
   GRPC_CHANNEL_STACK_REF(channel_stack_, "idle transport op");
+  // Initialize the transport op.
+  idle_transport_op_ = {};
   idle_transport_op_.disconnect_with_error = grpc_error_set_int(
       GRPC_ERROR_CREATE_FROM_STATIC_STRING("enter idle"),
       GRPC_ERROR_INT_CHANNEL_CONNECTIVITY_STATE, GRPC_CHANNEL_IDLE);