grpc 1.43.1 → 1.48.0

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

@@ -33,18 +33,14 @@ void grpc_create_socketpair_if_unix(int /* sv */[2]) {
   GPR_ASSERT(0);
 }
 
-grpc_error_handle grpc_resolve_unix_domain_address(
-    absl::string_view /* name */, grpc_resolved_addresses** addresses) {
-  *addresses = NULL;
-  return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-      "Unix domain sockets are not supported on Windows");
+absl::StatusOr<std::vector<grpc_resolved_address>>
+grpc_resolve_unix_domain_address(absl::string_view /* name */) {
+  return absl::UnknownError("Unix domain sockets are not supported on Windows");
 }
 
-grpc_error_handle grpc_resolve_unix_abstract_domain_address(
-    absl::string_view, grpc_resolved_addresses** addresses) {
-  *addresses = NULL;
-  return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-      "Unix domain sockets are not supported on Windows");
+absl::StatusOr<std::vector<grpc_resolved_address>>
+grpc_resolve_unix_abstract_domain_address(absl::string_view /* name */) {
+  return absl::UnknownError("Unix domain sockets are not supported on Windows");
 }
 
 int grpc_is_unix_socket(const grpc_resolved_address* /* addr */) {
@@ -54,9 +50,4 @@ int grpc_is_unix_socket(const grpc_resolved_address* /* addr */) {
 void grpc_unlink_if_unix_domain_socket(
     const grpc_resolved_address* /* addr */) {}
 
-std::string grpc_sockaddr_to_uri_unix_if_possible(
-    const grpc_resolved_address* /* addr */) {
-  return "";
-}
-
 #endif

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

@@ -41,9 +41,9 @@ static grpc_error_handle pipe_init(grpc_wakeup_fd* fd_info) {
   }
   grpc_error_handle err;
   err = grpc_set_socket_nonblocking(pipefd[0], 1);
-  if (err != GRPC_ERROR_NONE) return err;
+  if (!GRPC_ERROR_IS_NONE(err)) return err;
   err = grpc_set_socket_nonblocking(pipefd[1], 1);
-  if (err != GRPC_ERROR_NONE) return err;
+  if (!GRPC_ERROR_IS_NONE(err)) return err;
   fd_info->read_fd = pipefd[0];
   fd_info->write_fd = pipefd[1];
   return GRPC_ERROR_NONE;

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

@@ -32,22 +32,25 @@ static const grpc_wakeup_fd_vtable* wakeup_fd_vtable = nullptr;
 int grpc_allow_specialized_wakeup_fd = 1;
 int grpc_allow_pipe_wakeup_fd = 1;
 
-int has_real_wakeup_fd = 1;
-int cv_wakeup_fds_enabled = 0;
+static int has_real_wakeup_fd = 1;
+
+static gpr_once once_init_wakeup_fd = GPR_ONCE_INIT;
 
 void grpc_wakeup_fd_global_init(void) {
-  if (grpc_allow_specialized_wakeup_fd &&
-      grpc_specialized_wakeup_fd_vtable.check_availability()) {
-    wakeup_fd_vtable = &grpc_specialized_wakeup_fd_vtable;
-  } else if (grpc_allow_pipe_wakeup_fd &&
-             grpc_pipe_wakeup_fd_vtable.check_availability()) {
-    wakeup_fd_vtable = &grpc_pipe_wakeup_fd_vtable;
-  } else {
-    has_real_wakeup_fd = 0;
-  }
+  gpr_once_init(&once_init_wakeup_fd, []() {
+    if (grpc_allow_specialized_wakeup_fd &&
+        grpc_specialized_wakeup_fd_vtable.check_availability()) {
+      wakeup_fd_vtable = &grpc_specialized_wakeup_fd_vtable;
+    } else if (grpc_allow_pipe_wakeup_fd &&
+               grpc_pipe_wakeup_fd_vtable.check_availability()) {
+      wakeup_fd_vtable = &grpc_pipe_wakeup_fd_vtable;
+    } else {
+      has_real_wakeup_fd = 0;
+    }
+  });
 }
 
-void grpc_wakeup_fd_global_destroy(void) { wakeup_fd_vtable = nullptr; }
+void grpc_wakeup_fd_global_destroy(void) {}
 
 int grpc_has_wakeup_fd(void) { return has_real_wakeup_fd; }
 

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

@@ -59,8 +59,6 @@ void grpc_wakeup_fd_global_destroy(void);
 void grpc_wakeup_fd_global_init_force_fallback(void);
 
 int grpc_has_wakeup_fd(void);
-int grpc_cv_wakeup_fds_enabled(void);
-void grpc_enable_cv_wakeup_fds(int enable);
 
 typedef struct grpc_wakeup_fd grpc_wakeup_fd;
 

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

@@ -62,8 +62,8 @@ class WorkSerializer::WorkSerializerImpl : public Orphanable {
   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);
+  static uint64_t GetSize(uint64_t ref_pair) {
+    return static_cast<uint64_t>(ref_pair & 0xffffffffffffu);
   }
 
   // An initial size of 1 keeps track of whether the work serializer has been
@@ -121,10 +121,9 @@ void WorkSerializer::WorkSerializerImpl::Orphan() {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
     gpr_log(GPR_INFO, "WorkSerializer::Orphan() %p", this);
   }
-  uint64_t prev_ref_pair =
+  const 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 (GetOwners(prev_ref_pair) == 0 && GetSize(prev_ref_pair) == 1) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
       gpr_log(GPR_INFO, "  Destroying");
     }
@@ -170,13 +169,19 @@ void WorkSerializer::WorkSerializerImpl::DrainQueueOwned() {
       return;
     }
     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.
+      // Queue drained. Give up ownership but only if queue remains empty.
       uint64_t expected = MakeRefPair(1, 1);
       if (refs_.compare_exchange_strong(expected, MakeRefPair(0, 1),
-                                        std::memory_order_acq_rel,
-                                        std::memory_order_relaxed)) {
+                                        std::memory_order_acq_rel)) {
+        // Queue is drained.
+        return;
+      }
+      if (GetSize(expected) == 0) {
+        // WorkSerializer got orphaned while this was running
+        if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
+          gpr_log(GPR_INFO, "  Queue Drained. Destroying");
+        }
+        delete this;
         return;
       }
     }

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

@@ -16,6 +16,8 @@
  *
  */
 
+#ifndef GRPC_CORE_LIB_IOMGR_WORK_SERIALIZER_H
+#define GRPC_CORE_LIB_IOMGR_WORK_SERIALIZER_H
 #include <grpc/support/port_platform.h>
 
 #include <atomic>
@@ -30,9 +32,6 @@
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 
-#ifndef GRPC_CORE_LIB_IOMGR_WORK_SERIALIZER_H
-#define GRPC_CORE_LIB_IOMGR_WORK_SERIALIZER_H
-
 namespace grpc_core {
 
 // WorkSerializer is a mechanism to schedule callbacks in a synchronized manner.

data/src/core/lib/json/json.h

@@ -21,10 +21,9 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdlib.h>
-
 #include <map>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "absl/strings/string_view.h"

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

@@ -18,15 +18,23 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <string.h>
+#include <inttypes.h>
+#include <stdlib.h>
 
+#include <algorithm>
+#include <map>
 #include <string>
+#include <utility>
+#include <vector>
 
+#include "absl/base/attributes.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
+#include "absl/strings/string_view.h"
 
 #include <grpc/support/log.h>
 
+#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/json/json.h"
 
 #define GRPC_JSON_MAX_DEPTH 255

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

@@ -20,16 +20,23 @@
 
 #include "src/core/lib/json/json_util.h"
 
+#include <string.h>
+
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gprpp/memory.h"
 
 namespace grpc_core {
 
-bool ParseDurationFromJson(const Json& field, grpc_millis* duration) {
+bool ParseDurationFromJson(const Json& field, Duration* 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;
+  if (field.string_value() == Duration::Infinity().ToJsonString()) {
+    *duration = Duration::Infinity();
+    return true;
+  }
   UniquePtr<char> buf(gpr_strdup(field.string_value().c_str()));
   *(buf.get() + len - 1) = '\0';  // Remove trailing 's'.
   char* decimal_point = strchr(buf.get(), '.');
@@ -51,7 +58,7 @@ bool ParseDurationFromJson(const Json& field, grpc_millis* duration) {
   int seconds =
       decimal_point == buf.get() ? 0 : gpr_parse_nonnegative_int(buf.get());
   if (seconds == -1) return false;
-  *duration = seconds * GPR_MS_PER_SEC + nanos / GPR_NS_PER_MS;
+  *duration = Duration::FromSecondsAndNanoseconds(seconds, nanos);
   return true;
 }
 
@@ -99,7 +106,7 @@ bool ExtractJsonObject(const Json& json, absl::string_view field_name,
 
 bool ParseJsonObjectFieldAsDuration(const Json::Object& object,
                                     absl::string_view field_name,
-                                    grpc_millis* output,
+                                    Duration* output,
                                     std::vector<grpc_error_handle>* error_list,
                                     bool required) {
   // TODO(roth): Once we can use C++14 heterogenous lookups, stop
@@ -113,7 +120,7 @@ bool ParseJsonObjectFieldAsDuration(const Json::Object& object,
     return false;
   }
   if (!ParseDurationFromJson(it->second, output)) {
-    *output = GRPC_MILLIS_INF_PAST;
+    *output = Duration::NegativeInfinity();
     error_list->push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
         absl::StrCat("field:", field_name,
                      " error:type should be STRING of the form given by "

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

@@ -21,10 +21,19 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <algorithm>
+#include <map>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
 #include "absl/strings/numbers.h"
 #include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
 
-#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/json/json.h"
 
 namespace grpc_core {
@@ -33,7 +42,7 @@ namespace grpc_core {
 // proto message, as per:
 //   https://developers.google.com/protocol-buffers/docs/proto3#json
 // Returns true on success, false otherwise.
-bool ParseDurationFromJson(const Json& field, grpc_millis* duration);
+bool ParseDurationFromJson(const Json& field, Duration* duration);
 
 //
 // Helper functions for extracting types from JSON.
@@ -45,9 +54,9 @@ bool ExtractJsonNumber(const Json& json, absl::string_view field_name,
                        NumericType* output,
                        std::vector<grpc_error_handle>* error_list) {
   static_assert(std::is_integral<NumericType>::value, "Integral required");
-  if (json.type() != Json::Type::NUMBER) {
-    error_list->push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
-        absl::StrCat("field:", field_name, " error:type should be NUMBER")));
+  if (json.type() != Json::Type::NUMBER && json.type() != Json::Type::STRING) {
+    error_list->push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
+        "field:", field_name, " error:type should be NUMBER or STRING")));
     return false;
   }
   if (!absl::SimpleAtoi(json.string_value(), output)) {
@@ -145,7 +154,7 @@ bool ParseJsonObjectField(const Json::Object& object,
 // Alternative to ParseJsonObjectField() for duration-value fields.
 bool ParseJsonObjectFieldAsDuration(const Json::Object& object,
                                     absl::string_view field_name,
-                                    grpc_millis* output,
+                                    Duration* output,
                                     std::vector<grpc_error_handle>* error_list,
                                     bool required = true);
 

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

@@ -18,8 +18,13 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stdint.h>
 #include <stdlib.h>
-#include <string.h>
+
+#include <map>
+#include <string>
+#include <utility>
+#include <vector>
 
 #include "absl/strings/string_view.h"
 

data/src/core/lib/matchers/matchers.cc

@@ -16,11 +16,14 @@
 
 #include "src/core/lib/matchers/matchers.h"
 
+#include <utility>
+
 #include "absl/memory/memory.h"
-#include "absl/strings/str_cat.h"
+#include "absl/status/status.h"
+#include "absl/strings/ascii.h"
+#include "absl/strings/match.h"
+#include "absl/strings/numbers.h"
 #include "absl/strings/str_format.h"
-#include "absl/strings/str_join.h"
-#include "absl/strings/str_split.h"
 
 namespace grpc_core {
 
@@ -291,7 +294,7 @@ bool HeaderMatcher::Match(
     match = value.has_value() == present_match_;
   } else if (!value.has_value()) {
     // All other types fail to match if field is not present.
-    match = false;
+    return false;
   } else if (type_ == Type::kRange) {
     int64_t int_value;
     match = absl::SimpleAtoi(value.value(), &int_value) &&

data/src/core/lib/matchers/matchers.h

@@ -17,6 +17,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stdint.h>
+
 #include <memory>
 #include <string>
 

data/src/core/lib/promise/activity.cc

@@ -16,7 +16,7 @@
 
 #include "src/core/lib/promise/activity.h"
 
-#include "absl/base/attributes.h"
+#include <stddef.h>
 
 #include "src/core/lib/gprpp/atomic_utils.h"
 
@@ -26,16 +26,17 @@ namespace grpc_core {
 // GLOBALS
 
 GPR_THREAD_LOCAL(Activity*) Activity::g_current_activity_{nullptr};
-Waker::Unwakeable Waker::unwakeable_;
+
+namespace promise_detail {
 
 ///////////////////////////////////////////////////////////////////////////////
 // HELPER TYPES
 
 // Weak handle to an Activity.
 // Handle can persist while Activity goes away.
-class Activity::Handle final : public Wakeable {
+class FreestandingActivity::Handle final : public Wakeable {
  public:
-  explicit Handle(Activity* activity) : activity_(activity) {}
+  explicit Handle(FreestandingActivity* activity) : activity_(activity) {}
 
   // Ref the Handle (not the activity).
   void Ref() { refs_.fetch_add(1, std::memory_order_relaxed); }
@@ -57,7 +58,7 @@ class Activity::Handle final : public Wakeable {
     // against DropActivity, so we need to only increase activities refcount if
     // it is non-zero.
     if (activity_ && activity_->RefIfNonzero()) {
-      Activity* activity = activity_;
+      FreestandingActivity* activity = activity_;
       mu_.Unlock();
       // Activity still exists and we have a reference: wake it up, which will
       // drop the ref.
@@ -85,15 +86,15 @@ class Activity::Handle final : public Wakeable {
   // activity.
   std::atomic<size_t> refs_{2};
   Mutex mu_ ABSL_ACQUIRED_AFTER(activity_->mu_);
-  Activity* activity_ ABSL_GUARDED_BY(mu_);
+  FreestandingActivity* activity_ ABSL_GUARDED_BY(mu_);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // ACTIVITY IMPLEMENTATION
 
-bool Activity::RefIfNonzero() { return IncrementIfNonzero(&refs_); }
+bool FreestandingActivity::RefIfNonzero() { return IncrementIfNonzero(&refs_); }
 
-Activity::Handle* Activity::RefHandle() {
+FreestandingActivity::Handle* FreestandingActivity::RefHandle() {
   if (handle_ == nullptr) {
     // No handle created yet - construct it and return it.
     handle_ = new Handle(this);
@@ -105,11 +106,15 @@ Activity::Handle* Activity::RefHandle() {
   }
 }
 
-void Activity::DropHandle() {
+void FreestandingActivity::DropHandle() {
   handle_->DropActivity();
   handle_ = nullptr;
 }
 
-Waker Activity::MakeNonOwningWaker() { return Waker(RefHandle()); }
+Waker FreestandingActivity::MakeNonOwningWaker() {
+  mu_.AssertHeld();
+  return Waker(RefHandle());
+}
 
+}  // namespace promise_detail
 }  // namespace grpc_core