grpc 1.18.0 → 1.22.0

data/src/core/lib/gpr/string.cc

@@ -126,7 +126,8 @@ static void asciidump(dump_out* out, const char* buf, size_t len) {
   }
 }
 
-char* gpr_dump(const char* buf, size_t len, uint32_t flags) {
+char* gpr_dump_return_len(const char* buf, size_t len, uint32_t flags,
+                          size_t* out_len) {
   dump_out out = dump_out_create();
   if (flags & GPR_DUMP_HEX) {
     hexdump(&out, buf, len);
@@ -135,9 +136,15 @@ char* gpr_dump(const char* buf, size_t len, uint32_t flags) {
     asciidump(&out, buf, len);
   }
   dump_out_append(&out, 0);
+  *out_len = out.length;
   return out.data;
 }
 
+char* gpr_dump(const char* buf, size_t len, uint32_t flags) {
+  size_t unused;
+  return gpr_dump_return_len(buf, len, flags, &unused);
+}
+
 int gpr_parse_bytes_to_uint32(const char* buf, size_t len, uint32_t* result) {
   uint32_t out = 0;
   uint32_t new_val;
@@ -332,16 +339,22 @@ void* gpr_memrchr(const void* s, int c, size_t n) {
   return nullptr;
 }
 
-bool gpr_is_true(const char* s) {
-  size_t i;
+bool gpr_parse_bool_value(const char* s, bool* dst) {
+  const char* kTrue[] = {"1", "t", "true", "y", "yes"};
+  const char* kFalse[] = {"0", "f", "false", "n", "no"};
+  static_assert(sizeof(kTrue) == sizeof(kFalse), "true_false_equal");
+
   if (s == nullptr) {
     return false;
   }
-  static const char* truthy[] = {"yes", "true", "1"};
-  for (i = 0; i < GPR_ARRAY_SIZE(truthy); i++) {
-    if (0 == gpr_stricmp(s, truthy[i])) {
+  for (size_t i = 0; i < GPR_ARRAY_SIZE(kTrue); ++i) {
+    if (gpr_stricmp(s, kTrue[i]) == 0) {
+      *dst = true;
+      return true;
+    } else if (gpr_stricmp(s, kFalse[i]) == 0) {
+      *dst = false;
       return true;
     }
   }
-  return false;
+  return false;  // didn't match a legal input
 }

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

@@ -32,9 +32,14 @@
 #define GPR_DUMP_HEX 0x00000001
 #define GPR_DUMP_ASCII 0x00000002
 
-/* Converts array buf, of length len, into a C string  according to the flags.
+/* Converts array buf, of length len, into a C string according to the flags.
    Result should be freed with gpr_free() */
 char* gpr_dump(const char* buf, size_t len, uint32_t flags);
+/* Converts array buf, of length len, into a C string according to the flags.
+   The length of the returned buffer is stored in out_len.
+   Result should be freed with gpr_free() */
+char* gpr_dump_return_len(const char* buf, size_t len, uint32_t flags,
+                          size_t* out_len);
 
 /* Parses an array of bytes into an integer (base 10). Returns 1 on success,
    0 on failure. */
@@ -113,7 +118,9 @@ int gpr_stricmp(const char* a, const char* b);
 
 void* gpr_memrchr(const void* s, int c, size_t n);
 
-/** Return true if lower(s) equals "true", "yes" or "1", otherwise false. */
-bool gpr_is_true(const char* s);
+/* Try to parse given string into a boolean value.
+   When parsed successfully, dst will have the value and returns true.
+   Otherwise, it returns false. */
+bool gpr_parse_bool_value(const char* value, bool* dst);
 
 #endif /* GRPC_CORE_LIB_GPR_STRING_H */

data/src/core/lib/gpr/sync_posix.cc

@@ -18,6 +18,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <grpc/support/alloc.h>
+
 #ifdef GPR_POSIX_SYNC
 
 #include <errno.h>
@@ -72,27 +74,53 @@ gpr_atm gpr_counter_atm_add = 0;
 #endif
 
 void gpr_mu_init(gpr_mu* mu) {
+#ifdef GRPC_ASAN_ENABLED
+  GPR_ASSERT(pthread_mutex_init(&mu->mutex, nullptr) == 0);
+  mu->leak_checker = static_cast<int*>(malloc(sizeof(*mu->leak_checker)));
+  GPR_ASSERT(mu->leak_checker != nullptr);
+#else
   GPR_ASSERT(pthread_mutex_init(mu, nullptr) == 0);
+#endif
 }
 
-void gpr_mu_destroy(gpr_mu* mu) { GPR_ASSERT(pthread_mutex_destroy(mu) == 0); }
+void gpr_mu_destroy(gpr_mu* mu) {
+#ifdef GRPC_ASAN_ENABLED
+  GPR_ASSERT(pthread_mutex_destroy(&mu->mutex) == 0);
+  free(mu->leak_checker);
+#else
+  GPR_ASSERT(pthread_mutex_destroy(mu) == 0);
+#endif
+}
 
 void gpr_mu_lock(gpr_mu* mu) {
 #ifdef GPR_LOW_LEVEL_COUNTERS
   GPR_ATM_INC_COUNTER(gpr_mu_locks);
 #endif
   GPR_TIMER_SCOPE("gpr_mu_lock", 0);
+#ifdef GRPC_ASAN_ENABLED
+  GPR_ASSERT(pthread_mutex_lock(&mu->mutex) == 0);
+#else
   GPR_ASSERT(pthread_mutex_lock(mu) == 0);
+#endif
 }
 
 void gpr_mu_unlock(gpr_mu* mu) {
   GPR_TIMER_SCOPE("gpr_mu_unlock", 0);
+#ifdef GRPC_ASAN_ENABLED
+  GPR_ASSERT(pthread_mutex_unlock(&mu->mutex) == 0);
+#else
   GPR_ASSERT(pthread_mutex_unlock(mu) == 0);
+#endif
 }
 
 int gpr_mu_trylock(gpr_mu* mu) {
   GPR_TIMER_SCOPE("gpr_mu_trylock", 0);
-  int err = pthread_mutex_trylock(mu);
+  int err = 0;
+#ifdef GRPC_ASAN_ENABLED
+  err = pthread_mutex_trylock(&mu->mutex);
+#else
+  err = pthread_mutex_trylock(mu);
+#endif
   GPR_ASSERT(err == 0 || err == EBUSY);
   return err == 0;
 }
@@ -105,10 +133,24 @@ void gpr_cv_init(gpr_cv* cv) {
 #if GPR_LINUX
   GPR_ASSERT(pthread_condattr_setclock(&attr, CLOCK_MONOTONIC) == 0);
 #endif  // GPR_LINUX
+
+#ifdef GRPC_ASAN_ENABLED
+  GPR_ASSERT(pthread_cond_init(&cv->cond_var, &attr) == 0);
+  cv->leak_checker = static_cast<int*>(malloc(sizeof(*cv->leak_checker)));
+  GPR_ASSERT(cv->leak_checker != nullptr);
+#else
   GPR_ASSERT(pthread_cond_init(cv, &attr) == 0);
+#endif
 }
 
-void gpr_cv_destroy(gpr_cv* cv) { GPR_ASSERT(pthread_cond_destroy(cv) == 0); }
+void gpr_cv_destroy(gpr_cv* cv) {
+#ifdef GRPC_ASAN_ENABLED
+  GPR_ASSERT(pthread_cond_destroy(&cv->cond_var) == 0);
+  free(cv->leak_checker);
+#else
+  GPR_ASSERT(pthread_cond_destroy(cv) == 0);
+#endif
+}
 
 // For debug of the timer manager crash only.
 // TODO (mxyan): remove after bug is fixed.
@@ -169,7 +211,11 @@ int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline) {
 #endif
   if (gpr_time_cmp(abs_deadline, gpr_inf_future(abs_deadline.clock_type)) ==
       0) {
+#ifdef GRPC_ASAN_ENABLED
+    err = pthread_cond_wait(&cv->cond_var, &mu->mutex);
+#else
     err = pthread_cond_wait(cv, mu);
+#endif
   } else {
     struct timespec abs_deadline_ts;
 #if GPR_LINUX
@@ -181,7 +227,12 @@ int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline) {
 #endif  // GPR_LINUX
     abs_deadline_ts.tv_sec = static_cast<time_t>(abs_deadline.tv_sec);
     abs_deadline_ts.tv_nsec = abs_deadline.tv_nsec;
+#ifdef GRPC_ASAN_ENABLED
+    err = pthread_cond_timedwait(&cv->cond_var, &mu->mutex, &abs_deadline_ts);
+#else
     err = pthread_cond_timedwait(cv, mu, &abs_deadline_ts);
+#endif
+
 #ifdef GRPC_DEBUG_TIMER_MANAGER
     // For debug of the timer manager crash only.
     // TODO (mxyan): remove after bug is fixed.
@@ -226,10 +277,20 @@ int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline) {
   return err == ETIMEDOUT;
 }
 
-void gpr_cv_signal(gpr_cv* cv) { GPR_ASSERT(pthread_cond_signal(cv) == 0); }
+void gpr_cv_signal(gpr_cv* cv) {
+#ifdef GRPC_ASAN_ENABLED
+  GPR_ASSERT(pthread_cond_signal(&cv->cond_var) == 0);
+#else
+  GPR_ASSERT(pthread_cond_signal(cv) == 0);
+#endif
+}
 
 void gpr_cv_broadcast(gpr_cv* cv) {
+#ifdef GRPC_ASAN_ENABLED
+  GPR_ASSERT(pthread_cond_broadcast(&cv->cond_var) == 0);
+#else
   GPR_ASSERT(pthread_cond_broadcast(cv) == 0);
+#endif
 }
 
 /*----------------------------------------*/

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

@@ -135,6 +135,10 @@ gpr_timespec gpr_time_add(gpr_timespec a, gpr_timespec b) {
   gpr_timespec sum;
   int64_t inc = 0;
   GPR_ASSERT(b.clock_type == GPR_TIMESPAN);
+  // tv_nsec in a timespan is always +ve. -ve timespan is represented as (-ve
+  // tv_sec, +ve tv_nsec). For example, timespan = -2.5 seconds is represented
+  // as {-3, 5e8, GPR_TIMESPAN}
+  GPR_ASSERT(b.tv_nsec >= 0);
   sum.clock_type = a.clock_type;
   sum.tv_nsec = a.tv_nsec + b.tv_nsec;
   if (sum.tv_nsec >= GPR_NS_PER_SEC) {
@@ -165,6 +169,10 @@ gpr_timespec gpr_time_sub(gpr_timespec a, gpr_timespec b) {
   int64_t dec = 0;
   if (b.clock_type == GPR_TIMESPAN) {
     diff.clock_type = a.clock_type;
+    // tv_nsec in a timespan is always +ve. -ve timespan is represented as (-ve
+    // tv_sec, +ve tv_nsec). For example, timespan = -2.5 seconds is represented
+    // as {-3, 5e8, GPR_TIMESPAN}
+    GPR_ASSERT(b.tv_nsec >= 0);
   } else {
     GPR_ASSERT(a.clock_type == b.clock_type);
     diff.clock_type = GPR_TIMESPAN;

data/src/core/lib/gpr/time_posix.cc

@@ -108,6 +108,9 @@ static gpr_timespec now_impl(gpr_clock_type clock) {
   now.clock_type = clock;
   switch (clock) {
     case GPR_CLOCK_REALTIME:
+      // gettimeofday(...) function may return with a value whose tv_usec is
+      // greater than 1e6 on iOS The case is resolved with the guard at end of
+      // this function.
       gettimeofday(&now_tv, nullptr);
       now.tv_sec = now_tv.tv_sec;
       now.tv_nsec = now_tv.tv_usec * 1000;
@@ -124,6 +127,16 @@ static gpr_timespec now_impl(gpr_clock_type clock) {
       abort();
   }
 
+  // Guard the tv_nsec field in valid range for all clock types
+  while (GPR_UNLIKELY(now.tv_nsec >= 1e9)) {
+    now.tv_sec++;
+    now.tv_nsec -= 1e9;
+  }
+  while (GPR_UNLIKELY(now.tv_nsec < 0)) {
+    now.tv_sec--;
+    now.tv_nsec += 1e9;
+  }
+
   return now;
 }
 #endif
@@ -133,12 +146,18 @@ gpr_timespec (*gpr_now_impl)(gpr_clock_type clock_type) = now_impl;
 #ifdef GPR_LOW_LEVEL_COUNTERS
 gpr_atm gpr_now_call_count;
 #endif
-
 gpr_timespec gpr_now(gpr_clock_type clock_type) {
 #ifdef GPR_LOW_LEVEL_COUNTERS
   __atomic_fetch_add(&gpr_now_call_count, 1, __ATOMIC_RELAXED);
 #endif
-  return gpr_now_impl(clock_type);
+  // validate clock type
+  GPR_ASSERT(clock_type == GPR_CLOCK_MONOTONIC ||
+             clock_type == GPR_CLOCK_REALTIME ||
+             clock_type == GPR_CLOCK_PRECISE);
+  gpr_timespec ts = gpr_now_impl(clock_type);
+  // tv_nsecs must be in the range [0, 1e9).
+  GPR_ASSERT(ts.tv_nsec >= 0 && ts.tv_nsec < 1e9);
+  return ts;
 }
 
 void gpr_sleep_until(gpr_timespec until) {

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

@@ -0,0 +1,103 @@
+/*
+ *
+ * Copyright 2017 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/arena.h"
+
+#include <string.h>
+#include <new>
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/atm.h>
+#include <grpc/support/log.h>
+#include <grpc/support/sync.h>
+
+#include "src/core/lib/gpr/alloc.h"
+#include "src/core/lib/gprpp/memory.h"
+
+namespace {
+
+void* ArenaStorage(size_t initial_size) {
+  static constexpr size_t base_size =
+      GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_core::Arena));
+  initial_size = GPR_ROUND_UP_TO_ALIGNMENT_SIZE(initial_size);
+  size_t alloc_size = base_size + initial_size;
+  static constexpr size_t alignment =
+      (GPR_CACHELINE_SIZE > GPR_MAX_ALIGNMENT &&
+       GPR_CACHELINE_SIZE % GPR_MAX_ALIGNMENT == 0)
+          ? GPR_CACHELINE_SIZE
+          : GPR_MAX_ALIGNMENT;
+  return gpr_malloc_aligned(alloc_size, alignment);
+}
+
+}  // namespace
+
+namespace grpc_core {
+
+Arena::~Arena() {
+  Zone* z = last_zone_;
+  while (z) {
+    Zone* prev_z = z->prev;
+    z->~Zone();
+    gpr_free_aligned(z);
+    z = prev_z;
+  }
+}
+
+Arena* Arena::Create(size_t initial_size) {
+  return new (ArenaStorage(initial_size)) Arena(initial_size);
+}
+
+Pair<Arena*, void*> Arena::CreateWithAlloc(size_t initial_size,
+                                           size_t alloc_size) {
+  static constexpr size_t base_size =
+      GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(Arena));
+  auto* new_arena =
+      new (ArenaStorage(initial_size)) Arena(initial_size, alloc_size);
+  void* first_alloc = reinterpret_cast<char*>(new_arena) + base_size;
+  return MakePair(new_arena, first_alloc);
+}
+
+size_t Arena::Destroy() {
+  size_t size = total_used_.Load(MemoryOrder::RELAXED);
+  this->~Arena();
+  gpr_free_aligned(this);
+  return size;
+}
+
+void* Arena::AllocZone(size_t size) {
+  // If the allocation isn't able to end in the initial zone, create a new
+  // zone for this allocation, and any unused space in the initial zone is
+  // wasted. This overflowing and wasting is uncommon because of our arena
+  // sizing hysteresis (that is, most calls should have a large enough initial
+  // zone and will not need to grow the arena).
+  static constexpr size_t zone_base_size =
+      GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(Zone));
+  size_t alloc_size = zone_base_size + size;
+  Zone* z = new (gpr_malloc_aligned(alloc_size, GPR_MAX_ALIGNMENT)) Zone();
+  {
+    gpr_spinlock_lock(&arena_growth_spinlock_);
+    z->prev = last_zone_;
+    last_zone_ = z;
+    gpr_spinlock_unlock(&arena_growth_spinlock_);
+  }
+  return reinterpret_cast<char*>(z) + zone_base_size;
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,121 @@
+/*
+ *
+ * Copyright 2017 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.
+ *
+ */
+
+// \file Arena based allocator
+// Allows very fast allocation of memory, but that memory cannot be freed until
+// the arena as a whole is freed
+// Tracks the total memory allocated against it, so that future arenas can
+// pre-allocate the right amount of memory
+
+#ifndef GRPC_CORE_LIB_GPRPP_ARENA_H
+#define GRPC_CORE_LIB_GPRPP_ARENA_H
+
+#include <grpc/support/port_platform.h>
+
+#include <new>
+#include <utility>
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/sync.h>
+
+#include "src/core/lib/gpr/alloc.h"
+#include "src/core/lib/gpr/spinlock.h"
+#include "src/core/lib/gprpp/atomic.h"
+#include "src/core/lib/gprpp/pair.h"
+
+#include <stddef.h>
+
+namespace grpc_core {
+
+class Arena {
+ public:
+  // Create an arena, with \a initial_size bytes in the first allocated buffer.
+  static Arena* Create(size_t initial_size);
+
+  // Create an arena, with \a initial_size bytes in the first allocated buffer,
+  // and return both a void pointer to the returned arena and a void* with the
+  // first allocation.
+  static Pair<Arena*, void*> CreateWithAlloc(size_t initial_size,
+                                             size_t alloc_size);
+
+  // Destroy an arena, returning the total number of bytes allocated.
+  size_t Destroy();
+  // Allocate \a size bytes from the arena.
+  void* Alloc(size_t size) {
+    static constexpr size_t base_size =
+        GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(Arena));
+    size = GPR_ROUND_UP_TO_ALIGNMENT_SIZE(size);
+    size_t begin = total_used_.FetchAdd(size, MemoryOrder::RELAXED);
+    if (begin + size <= initial_zone_size_) {
+      return reinterpret_cast<char*>(this) + base_size + begin;
+    } else {
+      return AllocZone(size);
+    }
+  }
+
+  // TODO(roth): We currently assume that all callers need alignment of 16
+  // bytes, which may be wrong in some cases. When we have time, we should
+  // change this to instead use the alignment of the type being allocated by
+  // this method.
+  template <typename T, typename... Args>
+  T* New(Args&&... args) {
+    T* t = static_cast<T*>(Alloc(sizeof(T)));
+    new (t) T(std::forward<Args>(args)...);
+    return t;
+  }
+
+ private:
+  struct Zone {
+    Zone* prev;
+  };
+
+  // Initialize an arena.
+  // Parameters:
+  //   initial_size: The initial size of the whole arena in bytes. These bytes
+  //   are contained within 'zone 0'. If the arena user ends up requiring more
+  //   memory than the arena contains in zone 0, subsequent zones are allocated
+  //   on demand and maintained in a tail-linked list.
+  //
+  //   initial_alloc: Optionally, construct the arena as though a call to
+  //   Alloc() had already been made for initial_alloc bytes. This provides a
+  //   quick optimization (avoiding an atomic fetch-add) for the common case
+  //   where we wish to create an arena and then perform an immediate
+  //   allocation.
+  explicit Arena(size_t initial_size, size_t initial_alloc = 0)
+      : total_used_(initial_alloc), initial_zone_size_(initial_size) {}
+
+  ~Arena();
+
+  void* AllocZone(size_t size);
+
+  // Keep track of the total used size. We use this in our call sizing
+  // hysteresis.
+  Atomic<size_t> total_used_;
+  size_t initial_zone_size_;
+  gpr_spinlock arena_growth_spinlock_ = GPR_SPINLOCK_STATIC_INITIALIZER;
+  // If the initial arena allocation wasn't enough, we allocate additional zones
+  // in a reverse linked list. Each additional zone consists of (1) a pointer to
+  // the zone added before this zone (null if this is the first additional zone)
+  // and (2) the allocated memory. The arena itself maintains a pointer to the
+  // last zone; the zone list is reverse-walked during arena destruction only.
+  Zone* last_zone_ = nullptr;
+};
+
+}  // namespace grpc_core
+
+#endif /* GRPC_CORE_LIB_GPRPP_ARENA_H */

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

@@ -21,10 +21,80 @@
 
 #include <grpc/support/port_platform.h>
 
-#ifdef GPR_HAS_CXX11_ATOMIC
-#include "src/core/lib/gprpp/atomic_with_std.h"
-#else
-#include "src/core/lib/gprpp/atomic_with_atm.h"
-#endif
+#include <atomic>
+
+#include <grpc/support/atm.h>
+
+namespace grpc_core {
+
+enum class MemoryOrder {
+  RELAXED = std::memory_order_relaxed,
+  CONSUME = std::memory_order_consume,
+  ACQUIRE = std::memory_order_acquire,
+  RELEASE = std::memory_order_release,
+  ACQ_REL = std::memory_order_acq_rel,
+  SEQ_CST = std::memory_order_seq_cst
+};
+
+template <typename T>
+class Atomic {
+ public:
+  explicit Atomic(T val = T()) : storage_(val) {}
+
+  T Load(MemoryOrder order) const {
+    return storage_.load(static_cast<std::memory_order>(order));
+  }
+
+  void Store(T val, MemoryOrder order) {
+    storage_.store(val, static_cast<std::memory_order>(order));
+  }
+
+  bool CompareExchangeWeak(T* expected, T desired, MemoryOrder success,
+                           MemoryOrder failure) {
+    return GPR_ATM_INC_CAS_THEN(storage_.compare_exchange_weak(
+        *expected, desired, static_cast<std::memory_order>(success),
+        static_cast<std::memory_order>(failure)));
+  }
+
+  bool CompareExchangeStrong(T* expected, T desired, MemoryOrder success,
+                             MemoryOrder failure) {
+    return GPR_ATM_INC_CAS_THEN(storage_.compare_exchange_strong(
+        *expected, desired, static_cast<std::memory_order>(success),
+        static_cast<std::memory_order>(failure)));
+  }
+
+  template <typename Arg>
+  T FetchAdd(Arg arg, MemoryOrder order = MemoryOrder::SEQ_CST) {
+    return GPR_ATM_INC_ADD_THEN(storage_.fetch_add(
+        static_cast<Arg>(arg), static_cast<std::memory_order>(order)));
+  }
+
+  template <typename Arg>
+  T FetchSub(Arg arg, MemoryOrder order = MemoryOrder::SEQ_CST) {
+    return GPR_ATM_INC_ADD_THEN(storage_.fetch_sub(
+        static_cast<Arg>(arg), static_cast<std::memory_order>(order)));
+  }
+
+  // Atomically increment a counter only if the counter value is not zero.
+  // Returns true if increment took place; false if counter is zero.
+  bool IncrementIfNonzero(MemoryOrder load_order = MemoryOrder::ACQUIRE) {
+    T count = storage_.load(static_cast<std::memory_order>(load_order));
+    do {
+      // If zero, we are done (without an increment). If not, we must do a CAS
+      // to maintain the contract: do not increment the counter if it is already
+      // zero
+      if (count == 0) {
+        return false;
+      }
+    } while (!CompareExchangeWeak(&count, count + 1, MemoryOrder::ACQ_REL,
+                                  load_order));
+    return true;
+  }
+
+ private:
+  std::atomic<T> storage_;
+};
+
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_GPRPP_ATOMIC_H */

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

@@ -26,8 +26,8 @@
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
 
-#include "src/core/lib/gpr/env.h"
 #include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/global_config.h"
 #include "src/core/lib/gprpp/memory.h"
 
 /*
@@ -35,6 +35,16 @@
  *       AROUND VERY SPECIFIC USE CASES.
  */
 
+#ifdef GRPC_ENABLE_FORK_SUPPORT
+#define GRPC_ENABLE_FORK_SUPPORT_DEFAULT true
+#else
+#define GRPC_ENABLE_FORK_SUPPORT_DEFAULT false
+#endif  // GRPC_ENABLE_FORK_SUPPORT
+
+GPR_GLOBAL_CONFIG_DEFINE_BOOL(grpc_enable_fork_support,
+                              GRPC_ENABLE_FORK_SUPPORT_DEFAULT,
+                              "Enable folk support");
+
 namespace grpc_core {
 namespace internal {
 // The exec_ctx_count has 2 modes, blocked and unblocked.
@@ -158,36 +168,7 @@ class ThreadState {
 
 void Fork::GlobalInit() {
   if (!override_enabled_) {
-#ifdef GRPC_ENABLE_FORK_SUPPORT
-    support_enabled_ = true;
-#else
-    support_enabled_ = false;
-#endif
-    bool env_var_set = false;
-    char* env = gpr_getenv("GRPC_ENABLE_FORK_SUPPORT");
-    if (env != nullptr) {
-      static const char* truthy[] = {"yes",  "Yes",  "YES", "true",
-                                     "True", "TRUE", "1"};
-      static const char* falsey[] = {"no",    "No",    "NO", "false",
-                                     "False", "FALSE", "0"};
-      for (size_t i = 0; i < GPR_ARRAY_SIZE(truthy); i++) {
-        if (0 == strcmp(env, truthy[i])) {
-          support_enabled_ = true;
-          env_var_set = true;
-          break;
-        }
-      }
-      if (!env_var_set) {
-        for (size_t i = 0; i < GPR_ARRAY_SIZE(falsey); i++) {
-          if (0 == strcmp(env, falsey[i])) {
-            support_enabled_ = false;
-            env_var_set = true;
-            break;
-          }
-        }
-      }
-      gpr_free(env);
-    }
+    support_enabled_ = GPR_GLOBAL_CONFIG_GET(grpc_enable_fork_support);
   }
   if (support_enabled_) {
     exec_ctx_state_ = grpc_core::New<internal::ExecCtxState>();
@@ -262,7 +243,7 @@ void Fork::AwaitThreads() {
 
 internal::ExecCtxState* Fork::exec_ctx_state_ = nullptr;
 internal::ThreadState* Fork::thread_state_ = nullptr;
-bool Fork::support_enabled_ = false;
+std::atomic<bool> Fork::support_enabled_;
 bool Fork::override_enabled_ = false;
 Fork::child_postfork_func Fork::reset_child_polling_engine_ = nullptr;
 }  // namespace grpc_core

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

@@ -19,6 +19,10 @@
 #ifndef GRPC_CORE_LIB_GPRPP_FORK_H
 #define GRPC_CORE_LIB_GPRPP_FORK_H
 
+#include <grpc/support/port_platform.h>
+
+#include <atomic>
+
 /*
  * NOTE: FORKING IS NOT GENERALLY SUPPORTED, THIS IS ONLY INTENDED TO WORK
  *       AROUND VERY SPECIFIC USE CASES.
@@ -78,7 +82,7 @@ class Fork {
  private:
   static internal::ExecCtxState* exec_ctx_state_;
   static internal::ThreadState* thread_state_;
-  static bool support_enabled_;
+  static std::atomic<bool> support_enabled_;
   static bool override_enabled_;
   static child_postfork_func reset_child_polling_engine_;
 };