grpc 1.42.0 → 1.43.1

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

@@ -24,54 +24,79 @@ namespace grpc_core {
 
 DebugOnlyTraceFlag grpc_work_serializer_trace(false, "work_serializer");
 
-struct CallbackWrapper {
-  CallbackWrapper(std::function<void()> cb, const grpc_core::DebugLocation& loc)
-      : callback(std::move(cb)), location(loc) {}
-
-  MultiProducerSingleConsumerQueue::Node mpscq_node;
-  const std::function<void()> callback;
-  const DebugLocation location;
-};
-
 class WorkSerializer::WorkSerializerImpl : public Orphanable {
  public:
-  void Run(std::function<void()> callback,
-           const grpc_core::DebugLocation& location);
-
+  void Run(std::function<void()> callback, const DebugLocation& location);
+  void Schedule(std::function<void()> callback, const DebugLocation& location);
+  void DrainQueue();
   void Orphan() override;
 
  private:
-  void DrainQueue();
+  struct CallbackWrapper {
+    CallbackWrapper(std::function<void()> cb, const DebugLocation& loc)
+        : callback(std::move(cb)), location(loc) {}
+
+    MultiProducerSingleConsumerQueue::Node mpscq_node;
+    const std::function<void()> callback;
+    const DebugLocation location;
+  };
+
+  // Callers of DrainQueueOwned should make sure to grab the lock on the
+  // workserializer with
+  //
+  //   prev_ref_pair =
+  //     refs_.fetch_add(MakeRefPair(1, 1), std::memory_order_acq_rel);
+  //
+  // and only invoke DrainQueueOwned() if there was previously no owner. Note
+  // that the queue size is also incremented as part of the fetch_add to allow
+  // the callers to add a callback to the queue if another thread already holds
+  // the lock to the work serializer.
+  void DrainQueueOwned();
+
+  // First 16 bits indicate ownership of the WorkSerializer, next 48 bits are
+  // queue size (i.e., refs).
+  static uint64_t MakeRefPair(uint16_t owners, uint64_t size) {
+    GPR_ASSERT(size >> 48 == 0);
+    return (static_cast<uint64_t>(owners) << 48) + static_cast<int64_t>(size);
+  }
+  static uint32_t GetOwners(uint64_t ref_pair) {
+    return static_cast<uint32_t>(ref_pair >> 48);
+  }
+  static uint32_t GetSize(uint64_t ref_pair) {
+    return static_cast<uint32_t>(ref_pair & 0xffffffffffffu);
+  }
 
   // An initial size of 1 keeps track of whether the work serializer has been
   // orphaned.
-  std::atomic<size_t> size_{1};
+  std::atomic<uint64_t> refs_{MakeRefPair(0, 1)};
   MultiProducerSingleConsumerQueue queue_;
 };
 
-void WorkSerializer::WorkSerializerImpl::Run(
-    std::function<void()> callback, const grpc_core::DebugLocation& location) {
+void WorkSerializer::WorkSerializerImpl::Run(std::function<void()> callback,
+                                             const DebugLocation& location) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
     gpr_log(GPR_INFO, "WorkSerializer::Run() %p Scheduling callback [%s:%d]",
             this, location.file(), location.line());
   }
-  const size_t prev_size = size_.fetch_add(1);
+  // Increment queue size for the new callback and owner count to attempt to
+  // take ownership of the WorkSerializer.
+  const uint64_t prev_ref_pair =
+      refs_.fetch_add(MakeRefPair(1, 1), std::memory_order_acq_rel);
   // The work serializer should not have been orphaned.
-  GPR_DEBUG_ASSERT(prev_size > 0);
-  if (prev_size == 1) {
-    // There is no other closure executing right now on this work serializer.
-    // Execute this closure immediately.
+  GPR_DEBUG_ASSERT(GetSize(prev_ref_pair) > 0);
+  if (GetOwners(prev_ref_pair) == 0) {
+    // We took ownership of the WorkSerializer. Invoke callback and drain queue.
     if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
       gpr_log(GPR_INFO, "  Executing immediately");
     }
     callback();
-    // Loan this thread to the work serializer thread and drain the queue.
-    DrainQueue();
+    DrainQueueOwned();
   } else {
+    // Another thread is holding the WorkSerializer, so decrement the ownership
+    // count we just added and queue the callback.
+    refs_.fetch_sub(MakeRefPair(1, 0), std::memory_order_acq_rel);
     CallbackWrapper* cb_wrapper =
         new CallbackWrapper(std::move(callback), location);
-    // There already are closures executing on this work serializer. Simply add
-    // this closure to the queue.
     if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
       gpr_log(GPR_INFO, "  Scheduling on queue : item %p", cb_wrapper);
     }
@@ -79,12 +104,27 @@ void WorkSerializer::WorkSerializerImpl::Run(
   }
 }
 
+void WorkSerializer::WorkSerializerImpl::Schedule(
+    std::function<void()> callback, const DebugLocation& location) {
+  CallbackWrapper* cb_wrapper =
+      new CallbackWrapper(std::move(callback), location);
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
+    gpr_log(GPR_INFO,
+            "WorkSerializer::Schedule() %p Scheduling callback %p [%s:%d]",
+            this, cb_wrapper, location.file(), location.line());
+  }
+  refs_.fetch_add(MakeRefPair(0, 1), std::memory_order_acq_rel);
+  queue_.Push(&cb_wrapper->mpscq_node);
+}
+
 void WorkSerializer::WorkSerializerImpl::Orphan() {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
     gpr_log(GPR_INFO, "WorkSerializer::Orphan() %p", this);
   }
-  size_t prev_size = size_.fetch_sub(1);
-  if (prev_size == 1) {
+  uint64_t prev_ref_pair =
+      refs_.fetch_sub(MakeRefPair(0, 1), std::memory_order_acq_rel);
+  if (GetSize(prev_ref_pair) == 1) {
+    GPR_DEBUG_ASSERT(GetOwners(prev_ref_pair) == 0);
     if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
       gpr_log(GPR_INFO, "  Destroying");
     }
@@ -93,30 +133,52 @@ void WorkSerializer::WorkSerializerImpl::Orphan() {
 }
 
 // The thread that calls this loans itself to the work serializer so as to
-// execute all the scheduled callback. This is called from within
-// WorkSerializer::Run() after executing a callback immediately, and hence size_
-// is at least 1.
+// execute all the scheduled callbacks.
 void WorkSerializer::WorkSerializerImpl::DrainQueue() {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
+    gpr_log(GPR_INFO, "WorkSerializer::DrainQueue() %p", this);
+  }
+  // Attempt to take ownership of the WorkSerializer. Also increment the queue
+  // size as required by `DrainQueueOwned()`.
+  const uint64_t prev_ref_pair =
+      refs_.fetch_add(MakeRefPair(1, 1), std::memory_order_acq_rel);
+  if (GetOwners(prev_ref_pair) == 0) {
+    // We took ownership of the WorkSerializer. Drain the queue.
+    DrainQueueOwned();
+  } else {
+    // Another thread is holding the WorkSerializer, so decrement the ownership
+    // count we just added and queue a no-op callback.
+    refs_.fetch_sub(MakeRefPair(1, 0), std::memory_order_acq_rel);
+    CallbackWrapper* cb_wrapper = new CallbackWrapper([]() {}, DEBUG_LOCATION);
+    queue_.Push(&cb_wrapper->mpscq_node);
+  }
+}
+
+void WorkSerializer::WorkSerializerImpl::DrainQueueOwned() {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
+    gpr_log(GPR_INFO, "WorkSerializer::DrainQueueOwned() %p", this);
+  }
   while (true) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
-      gpr_log(GPR_INFO, "WorkSerializer::DrainQueue() %p", this);
-    }
-    size_t prev_size = size_.fetch_sub(1);
-    GPR_DEBUG_ASSERT(prev_size >= 1);
-    // It is possible that while draining the queue, one of the callbacks ended
+    auto prev_ref_pair = refs_.fetch_sub(MakeRefPair(0, 1));
+    // It is possible that while draining the queue, the last callback ended
     // up orphaning the work serializer. In that case, delete the object.
-    if (prev_size == 1) {
+    if (GetSize(prev_ref_pair) == 1) {
       if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
         gpr_log(GPR_INFO, "  Queue Drained. Destroying");
       }
       delete this;
       return;
     }
-    if (prev_size == 2) {
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
-        gpr_log(GPR_INFO, "  Queue Drained");
+    if (GetSize(prev_ref_pair) == 2) {
+      // Queue drained. Give up ownership but only if queue remains empty. Note
+      // that we are using relaxed memory order semantics for the load on
+      // failure since we don't care about that value.
+      uint64_t expected = MakeRefPair(1, 1);
+      if (refs_.compare_exchange_strong(expected, MakeRefPair(0, 1),
+                                        std::memory_order_acq_rel,
+                                        std::memory_order_relaxed)) {
+        return;
       }
-      return;
     }
     // There is at least one callback on the queue. Pop the callback from the
     // queue and execute it.
@@ -124,8 +186,8 @@ void WorkSerializer::WorkSerializerImpl::DrainQueue() {
     bool empty_unused;
     while ((cb_wrapper = reinterpret_cast<CallbackWrapper*>(
                 queue_.PopAndCheckEnd(&empty_unused))) == nullptr) {
-      // This can happen either due to a race condition within the mpscq
-      // implementation or because of a race with Run()
+      // This can happen due to a race condition within the mpscq
+      // implementation or because of a race with Run()/Schedule().
       if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
         gpr_log(GPR_INFO, "  Queue returned nullptr, trying again");
       }
@@ -140,7 +202,9 @@ void WorkSerializer::WorkSerializerImpl::DrainQueue() {
   }
 }
 
+//
 // WorkSerializer
+//
 
 WorkSerializer::WorkSerializer()
     : impl_(MakeOrphanable<WorkSerializerImpl>()) {}
@@ -148,8 +212,15 @@ WorkSerializer::WorkSerializer()
 WorkSerializer::~WorkSerializer() {}
 
 void WorkSerializer::Run(std::function<void()> callback,
-                         const grpc_core::DebugLocation& location) {
+                         const DebugLocation& location) {
   impl_->Run(std::move(callback), location);
 }
 
+void WorkSerializer::Schedule(std::function<void()> callback,
+                              const DebugLocation& location) {
+  impl_->Schedule(std::move(callback), location);
+}
+
+void WorkSerializer::DrainQueue() { impl_->DrainQueue(); }
+
 }  // namespace grpc_core

data/src/core/lib/iomgr/work_serializer.h

@@ -45,13 +45,20 @@ namespace grpc_core {
 // other callbacks from other threads might also be executed before Run()
 // returns. Since an arbitrary set of callbacks might be executed when Run() is
 // called, generally no locks should be held while calling Run().
+// If a thread wants to preclude the possibility of the callback being invoked
+// inline in Run() (for example, if a mutex lock is held and executing callbacks
+// inline would cause a deadlock), it should use Schedule() instead and then
+// invoke DrainQueue() when it is safe to invoke the callback.
 class ABSL_LOCKABLE WorkSerializer {
  public:
   WorkSerializer();
 
   ~WorkSerializer();
 
-  // Runs a given callback.
+  // Runs a given callback on the work serializer. If there is no other thread
+  // currently executing the WorkSerializer, the callback is run immediately. In
+  // this case, the current thread is also borrowed for draining the queue for
+  // any callbacks that get added in the meantime.
   //
   // If you want to use clang thread annotation to make sure that callback is
   // called by WorkSerializer only, you need to add the annotation to both the
@@ -65,10 +72,15 @@ class ABSL_LOCKABLE WorkSerializer {
   //   }
   //   void callback() ABSL_EXCLUSIVE_LOCKS_REQUIRED(work_serializer) { ... }
   //
-  // TODO(yashkt): Replace grpc_core::DebugLocation with absl::SourceLocation
+  // TODO(yashkt): Replace DebugLocation with absl::SourceLocation
   // once we can start using it directly.
-  void Run(std::function<void()> callback,
-           const grpc_core::DebugLocation& location);
+  void Run(std::function<void()> callback, const DebugLocation& location);
+
+  // Schedule \a callback to be run later when the queue of callbacks is
+  // drained.
+  void Schedule(std::function<void()> callback, const DebugLocation& location);
+  // Drains the queue of callbacks.
+  void DrainQueue();
 
  private:
   class WorkSerializerImpl;

data/src/core/lib/json/json_reader.cc

@@ -95,8 +95,8 @@ class JsonReader {
 
   size_t CurrentIndex() const { return input_ - original_input_ - 1; }
 
-  void StringAddChar(uint32_t c);
-  void StringAddUtf32(uint32_t c);
+  GRPC_MUST_USE_RESULT bool StringAddChar(uint32_t c);
+  GRPC_MUST_USE_RESULT bool StringAddUtf32(uint32_t c);
 
   Json* CreateAndLinkValue();
   bool StartContainer(Json::Type type);
@@ -119,6 +119,7 @@ class JsonReader {
   uint16_t unicode_high_surrogate_ = 0;
   std::vector<grpc_error_handle> errors_;
   bool truncated_errors_ = false;
+  uint8_t utf8_bytes_remaining_ = 0;
 
   Json root_value_;
   std::vector<Json*> stack_;
@@ -127,34 +128,55 @@ class JsonReader {
   std::string string_;
 };
 
-void JsonReader::StringAddChar(uint32_t c) {
+bool JsonReader::StringAddChar(uint32_t c) {
+  switch (utf8_bytes_remaining_) {
+    case 0:
+      if ((c & 0x80) == 0) {
+        utf8_bytes_remaining_ = 0;
+      } else if ((c & 0xe0) == 0xc0) {
+        utf8_bytes_remaining_ = 1;
+      } else if ((c & 0xf0) == 0xe0) {
+        utf8_bytes_remaining_ = 2;
+      } else if ((c & 0xf8) == 0xf0) {
+        utf8_bytes_remaining_ = 3;
+      } else {
+        return false;
+      }
+      break;
+    case 1:
+    case 2:
+    case 3:
+      if ((c & 0xc0) != 0x80) return false;
+      --utf8_bytes_remaining_;
+      break;
+    default:
+      abort();
+  }
   string_.push_back(static_cast<uint8_t>(c));
+  return true;
 }
 
-void JsonReader::StringAddUtf32(uint32_t c) {
+bool JsonReader::StringAddUtf32(uint32_t c) {
   if (c <= 0x7f) {
-    StringAddChar(c);
+    return StringAddChar(c);
   } else if (c <= 0x7ff) {
     uint32_t b1 = 0xc0 | ((c >> 6) & 0x1f);
     uint32_t b2 = 0x80 | (c & 0x3f);
-    StringAddChar(b1);
-    StringAddChar(b2);
+    return StringAddChar(b1) && StringAddChar(b2);
   } else if (c <= 0xffff) {
     uint32_t b1 = 0xe0 | ((c >> 12) & 0x0f);
     uint32_t b2 = 0x80 | ((c >> 6) & 0x3f);
     uint32_t b3 = 0x80 | (c & 0x3f);
-    StringAddChar(b1);
-    StringAddChar(b2);
-    StringAddChar(b3);
+    return StringAddChar(b1) && StringAddChar(b2) && StringAddChar(b3);
   } else if (c <= 0x1fffff) {
     uint32_t b1 = 0xf0 | ((c >> 18) & 0x07);
     uint32_t b2 = 0x80 | ((c >> 12) & 0x3f);
     uint32_t b3 = 0x80 | ((c >> 6) & 0x3f);
     uint32_t b4 = 0x80 | (c & 0x3f);
-    StringAddChar(b1);
-    StringAddChar(b2);
-    StringAddChar(b3);
-    StringAddChar(b4);
+    return StringAddChar(b1) && StringAddChar(b2) && StringAddChar(b3) &&
+           StringAddChar(b4);
+  } else {
+    return false;
   }
 }
 
@@ -275,6 +297,18 @@ JsonReader::Status JsonReader::Run() {
     switch (c) {
       /* Let's process the error case first. */
       case GRPC_JSON_READ_CHAR_EOF:
+        switch (state_) {
+          case State::GRPC_JSON_STATE_VALUE_NUMBER:
+          case State::GRPC_JSON_STATE_VALUE_NUMBER_WITH_DECIMAL:
+          case State::GRPC_JSON_STATE_VALUE_NUMBER_ZERO:
+          case State::GRPC_JSON_STATE_VALUE_NUMBER_EPM:
+            if (!SetNumber()) return Status::GRPC_JSON_PARSE_ERROR;
+            state_ = State::GRPC_JSON_STATE_VALUE_END;
+            break;
+
+          default:
+            break;
+        }
         if (IsComplete()) {
           return Status::GRPC_JSON_DONE;
         }
@@ -299,7 +333,7 @@ JsonReader::Status JsonReader::Run() {
             if (unicode_high_surrogate_ != 0) {
               return Status::GRPC_JSON_PARSE_ERROR;
             }
-            StringAddChar(c);
+            if (!StringAddChar(c)) return Status::GRPC_JSON_PARSE_ERROR;
             break;
 
           case State::GRPC_JSON_STATE_VALUE_NUMBER:
@@ -325,7 +359,7 @@ JsonReader::Status JsonReader::Run() {
             if (unicode_high_surrogate_ != 0) {
               return Status::GRPC_JSON_PARSE_ERROR;
             }
-            StringAddChar(c);
+            if (!StringAddChar(c)) return Status::GRPC_JSON_PARSE_ERROR;
             break;
 
           case State::GRPC_JSON_STATE_VALUE_NUMBER:
@@ -410,7 +444,7 @@ JsonReader::Status JsonReader::Run() {
             if (unicode_high_surrogate_ != 0) {
               return Status::GRPC_JSON_PARSE_ERROR;
             }
-            StringAddChar('\\');
+            if (!StringAddChar('\\')) return Status::GRPC_JSON_PARSE_ERROR;
             if (escaped_string_was_key_) {
               state_ = State::GRPC_JSON_STATE_OBJECT_KEY_STRING;
             } else {
@@ -437,10 +471,15 @@ JsonReader::Status JsonReader::Run() {
             }
             if (c == '"') {
               state_ = State::GRPC_JSON_STATE_OBJECT_KEY_END;
+              // Once the key is parsed, there should no un-matched utf8
+              // encoded bytes.
+              if (utf8_bytes_remaining_ != 0) {
+                return Status::GRPC_JSON_PARSE_ERROR;
+              }
               SetKey();
             } else {
               if (c < 32) return Status::GRPC_JSON_PARSE_ERROR;
-              StringAddChar(c);
+              if (!StringAddChar(c)) return Status::GRPC_JSON_PARSE_ERROR;
             }
             break;
 
@@ -450,10 +489,15 @@ JsonReader::Status JsonReader::Run() {
             }
             if (c == '"') {
               state_ = State::GRPC_JSON_STATE_VALUE_END;
+              // Once the value is parsed, there should no un-matched utf8
+              // encoded bytes.
+              if (utf8_bytes_remaining_ != 0) {
+                return Status::GRPC_JSON_PARSE_ERROR;
+              }
               SetString();
             } else {
               if (c < 32) return Status::GRPC_JSON_PARSE_ERROR;
-              StringAddChar(c);
+              if (!StringAddChar(c)) return Status::GRPC_JSON_PARSE_ERROR;
             }
             break;
 
@@ -481,7 +525,7 @@ JsonReader::Status JsonReader::Run() {
                 break;
 
               case '0':
-                StringAddChar(c);
+                if (!StringAddChar(c)) return Status::GRPC_JSON_PARSE_ERROR;
                 state_ = State::GRPC_JSON_STATE_VALUE_NUMBER_ZERO;
                 break;
 
@@ -495,7 +539,7 @@ JsonReader::Status JsonReader::Run() {
               case '8':
               case '9':
               case '-':
-                StringAddChar(c);
+                if (!StringAddChar(c)) return Status::GRPC_JSON_PARSE_ERROR;
                 state_ = State::GRPC_JSON_STATE_VALUE_NUMBER;
                 break;
 
@@ -530,22 +574,22 @@ JsonReader::Status JsonReader::Run() {
             switch (c) {
               case '"':
               case '/':
-                StringAddChar(c);
+                if (!StringAddChar(c)) return Status::GRPC_JSON_PARSE_ERROR;
                 break;
               case 'b':
-                StringAddChar('\b');
+                if (!StringAddChar('\b')) return Status::GRPC_JSON_PARSE_ERROR;
                 break;
               case 'f':
-                StringAddChar('\f');
+                if (!StringAddChar('\f')) return Status::GRPC_JSON_PARSE_ERROR;
                 break;
               case 'n':
-                StringAddChar('\n');
+                if (!StringAddChar('\n')) return Status::GRPC_JSON_PARSE_ERROR;
                 break;
               case 'r':
-                StringAddChar('\r');
+                if (!StringAddChar('\r')) return Status::GRPC_JSON_PARSE_ERROR;
                 break;
               case 't':
-                StringAddChar('\t');
+                if (!StringAddChar('\t')) return Status::GRPC_JSON_PARSE_ERROR;
                 break;
               case 'u':
                 state_ = State::GRPC_JSON_STATE_STRING_ESCAPE_U1;
@@ -602,14 +646,18 @@ JsonReader::Status JsonReader::Run() {
                   utf32 += static_cast<uint32_t>(
                       (unicode_high_surrogate_ - 0xd800) * 0x400);
                   utf32 += static_cast<uint32_t>(unicode_char_ - 0xdc00);
-                  StringAddUtf32(utf32);
+                  if (!StringAddUtf32(utf32)) {
+                    return Status::GRPC_JSON_PARSE_ERROR;
+                  }
                   unicode_high_surrogate_ = 0;
                 } else {
                   /* anything else */
                   if (unicode_high_surrogate_ != 0) {
                     return Status::GRPC_JSON_PARSE_ERROR;
                   }
-                  StringAddUtf32(unicode_char_);
+                  if (!StringAddUtf32(unicode_char_)) {
+                    return Status::GRPC_JSON_PARSE_ERROR;
+                  }
                 }
                 if (escaped_string_was_key_) {
                   state_ = State::GRPC_JSON_STATE_OBJECT_KEY_STRING;
@@ -623,7 +671,7 @@ JsonReader::Status JsonReader::Run() {
             break;
 
           case State::GRPC_JSON_STATE_VALUE_NUMBER:
-            StringAddChar(c);
+            if (!StringAddChar(c)) return Status::GRPC_JSON_PARSE_ERROR;
             switch (c) {
               case '0':
               case '1':
@@ -649,7 +697,7 @@ JsonReader::Status JsonReader::Run() {
             break;
 
           case State::GRPC_JSON_STATE_VALUE_NUMBER_WITH_DECIMAL:
-            StringAddChar(c);
+            if (!StringAddChar(c)) return Status::GRPC_JSON_PARSE_ERROR;
             switch (c) {
               case '0':
               case '1':
@@ -673,12 +721,12 @@ JsonReader::Status JsonReader::Run() {
 
           case State::GRPC_JSON_STATE_VALUE_NUMBER_ZERO:
             if (c != '.') return Status::GRPC_JSON_PARSE_ERROR;
-            StringAddChar(c);
+            if (!StringAddChar(c)) return Status::GRPC_JSON_PARSE_ERROR;
             state_ = State::GRPC_JSON_STATE_VALUE_NUMBER_DOT;
             break;
 
           case State::GRPC_JSON_STATE_VALUE_NUMBER_DOT:
-            StringAddChar(c);
+            if (!StringAddChar(c)) return Status::GRPC_JSON_PARSE_ERROR;
             switch (c) {
               case '0':
               case '1':
@@ -698,7 +746,7 @@ JsonReader::Status JsonReader::Run() {
             break;
 
           case State::GRPC_JSON_STATE_VALUE_NUMBER_E:
-            StringAddChar(c);
+            if (!StringAddChar(c)) return Status::GRPC_JSON_PARSE_ERROR;
             switch (c) {
               case '0':
               case '1':
@@ -720,7 +768,7 @@ JsonReader::Status JsonReader::Run() {
             break;
 
           case State::GRPC_JSON_STATE_VALUE_NUMBER_EPM:
-            StringAddChar(c);
+            if (!StringAddChar(c)) return Status::GRPC_JSON_PARSE_ERROR;
             switch (c) {
               case '0':
               case '1':

data/src/core/lib/json/json_util.cc

@@ -30,7 +30,7 @@ bool ParseDurationFromJson(const Json& field, grpc_millis* duration) {
   if (field.type() != Json::Type::STRING) return false;
   size_t len = field.string_value().size();
   if (field.string_value()[len - 1] != 's') return false;
-  grpc_core::UniquePtr<char> buf(gpr_strdup(field.string_value().c_str()));
+  UniquePtr<char> buf(gpr_strdup(field.string_value().c_str()));
   *(buf.get() + len - 1) = '\0';  // Remove trailing 's'.
   char* decimal_point = strchr(buf.get(), '.');
   int nanos = 0;