grpc 1.38.0 → 1.40.0

data/src/core/lib/channel/channel_stack.h

@@ -78,7 +78,7 @@ struct grpc_call_element_args {
   const void* server_transport_data;
   grpc_call_context_element* context;
   const grpc_slice& path;
-  gpr_cycle_counter start_time;
+  gpr_cycle_counter start_time;  // Note: not populated in subchannel stack.
   grpc_millis deadline;
   grpc_core::Arena* arena;
   grpc_core::CallCombiner* call_combiner;

data/src/core/lib/channel/channelz.h

@@ -276,6 +276,9 @@ class SocketNode : public BaseNode {
  public:
   struct Security : public RefCounted<Security> {
     struct Tls {
+      // This is a workaround for https://bugs.llvm.org/show_bug.cgi?id=50346
+      Tls() {}
+
       enum class NameType { kUnset = 0, kStandardName = 1, kOtherName = 2 };
       NameType type = NameType::kUnset;
       // Holds the value of standard_name or other_names if type is not kUnset.

data/src/core/lib/channel/context.h

@@ -32,6 +32,9 @@ typedef enum {
   /// Value is a \a census_context.
   GRPC_CONTEXT_TRACING,
 
+  /// Value is a CallTracer object.
+  GRPC_CONTEXT_CALL_TRACER,
+
   /// Reserved for traffic_class_context.
   GRPC_CONTEXT_TRAFFIC,
 

data/src/core/lib/channel/status_util.h

@@ -53,6 +53,10 @@ class StatusCodeSet {
     return status_code_mask_ & (1 << status);
   }
 
+  bool operator==(const StatusCodeSet& other) const {
+    return status_code_mask_ == other.status_code_mask_;
+  }
+
  private:
   int status_code_mask_ = 0;  // A bitfield of status codes in the set.
 };

data/src/core/lib/compression/stream_compression.h

@@ -113,4 +113,4 @@ void grpc_stream_compression_context_destroy(
 int grpc_stream_compression_method_parse(
     grpc_slice value, bool is_compress, grpc_stream_compression_method* method);
 
-#endif
+#endif  // GRPC_CORE_LIB_COMPRESSION_STREAM_COMPRESSION_H

data/src/core/lib/compression/stream_compression_gzip.h

@@ -25,4 +25,4 @@
 
 extern const grpc_stream_compression_vtable grpc_stream_compression_gzip_vtable;
 
-#endif
+#endif  // GRPC_CORE_LIB_COMPRESSION_STREAM_COMPRESSION_GZIP_H

data/src/core/lib/compression/stream_compression_identity.h

@@ -26,4 +26,4 @@
 extern const grpc_stream_compression_vtable
     grpc_stream_compression_identity_vtable;
 
-#endif
+#endif  // GRPC_CORE_LIB_COMPRESSION_STREAM_COMPRESSION_IDENTITY_H

data/src/core/lib/debug/stats.h

@@ -67,4 +67,4 @@ double grpc_stats_histo_percentile(const grpc_stats_data* stats,
 size_t grpc_stats_histo_count(const grpc_stats_data* stats,
                               grpc_stats_histograms histogram);
 
-#endif
+#endif  // GRPC_CORE_LIB_DEBUG_STATS_H

data/src/core/lib/event_engine/endpoint_config.cc

@@ -0,0 +1,46 @@
+// Copyright 2021 The 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 <grpc/event_engine/endpoint_config.h>
+
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/impl/codegen/log.h>
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/event_engine/endpoint_config_internal.h"
+#include "src/core/lib/gpr/useful.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+EndpointConfig::Setting ChannelArgsEndpointConfig::Get(
+    absl::string_view key) const {
+  const grpc_arg* arg = grpc_channel_args_find(args_, std::string(key).c_str());
+  if (arg == nullptr) {
+    return absl::monostate();
+  }
+  switch (arg->type) {
+    case GRPC_ARG_STRING:
+      return absl::string_view(arg->value.string);
+    case GRPC_ARG_INTEGER:
+      return arg->value.integer;
+    case GRPC_ARG_POINTER:
+      return arg->value.pointer.p;
+  }
+  GPR_UNREACHABLE_CODE(return absl::monostate());
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine

data/src/core/lib/event_engine/endpoint_config_internal.h

@@ -0,0 +1,42 @@
+// Copyright 2021 The 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_LIB_EVENT_ENGINE_ENDPOINT_CONFIG_INTERNAL_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_ENDPOINT_CONFIG_INTERNAL_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/event_engine/endpoint_config.h>
+
+#include "src/core/lib/channel/channel_args.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+/// A readonly \a EndpointConfig based on grpc_channel_args. This class does not
+/// take ownership of the grpc_endpoint_args*, and instances of this class
+/// should not be used after the underlying args are destroyed.
+class ChannelArgsEndpointConfig : public EndpointConfig {
+ public:
+  explicit ChannelArgsEndpointConfig(const grpc_channel_args* args)
+      : args_(args) {}
+  Setting Get(absl::string_view key) const override;
+
+ private:
+  const grpc_channel_args* args_;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_ENDPOINT_CONFIG_INTERNAL_H

data/src/core/lib/event_engine/event_engine.cc

@@ -0,0 +1,50 @@
+// Copyright 2021 The 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 <grpc/event_engine/endpoint_config.h>
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/event_engine/port.h>
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/support/log.h>
+
+#include "absl/strings/str_format.h"
+#include "absl/strings/str_join.h"
+
+#include "src/core/lib/event_engine/sockaddr.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+EventEngine::ResolvedAddress::ResolvedAddress(const sockaddr* address,
+                                              socklen_t size)
+    : size_(size) {
+  GPR_ASSERT(size <= sizeof(address_));
+  memcpy(&address_, address, size);
+}
+
+const struct sockaddr* EventEngine::ResolvedAddress::address() const {
+  return reinterpret_cast<const struct sockaddr*>(address_);
+}
+
+socklen_t EventEngine::ResolvedAddress::size() const { return size_; }
+
+std::shared_ptr<grpc_event_engine::experimental::EventEngine>
+DefaultEventEngineFactory() {
+  // TODO(nnoble): delete when uv-ee is merged
+  abort();
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine

data/src/core/lib/event_engine/sockaddr.cc

@@ -13,26 +13,28 @@
 // limitations under the License.
 #include <grpc/support/port_platform.h>
 
+#ifdef GRPC_USE_EVENT_ENGINE
 #include <string.h>
 
 #include "grpc/event_engine/event_engine.h"
 #include "grpc/event_engine/port.h"
 #include "grpc/support/log.h"
 
-namespace grpc_event_engine {
-namespace experimental {
+uint16_t grpc_htons(uint16_t hostshort) { return htons(hostshort); }
 
-EventEngine::ResolvedAddress::ResolvedAddress(const sockaddr* address,
-                                              socklen_t size) {
-  GPR_ASSERT(size <= sizeof(address_));
-  memcpy(&address_, address, size);
-}
+uint16_t grpc_ntohs(uint16_t netshort) { return ntohs(netshort); }
+
+uint32_t grpc_htonl(uint32_t hostlong) { return htonl(hostlong); }
 
-const struct sockaddr* EventEngine::ResolvedAddress::address() const {
-  return reinterpret_cast<const struct sockaddr*>(address_);
+uint32_t grpc_ntohl(uint32_t netlong) { return ntohl(netlong); }
+
+int grpc_inet_pton(int af, const char* src, void* dst) {
+  return inet_pton(af, src, dst);
 }
 
-socklen_t EventEngine::ResolvedAddress::size() const { return size_; }
+const char* grpc_inet_ntop(int af, const void* src, char* dst, size_t size) {
+  inet_ntop(af, src, dst, size);
+  return dst;
+}
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+#endif  // GRPC_USE_EVENT_ENGINE

data/src/core/lib/event_engine/sockaddr.h

@@ -0,0 +1,44 @@
+// Copyright 2021 The 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_LIB_EVENT_ENGINE_SOCKADDR_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_SOCKADDR_H
+
+#include <grpc/support/port_platform.h>
+
+#ifdef GRPC_USE_EVENT_ENGINE
+#include <grpc/event_engine/port.h>
+
+#include "src/core/lib/iomgr/port.h"
+
+typedef struct sockaddr grpc_sockaddr;
+typedef struct sockaddr_in grpc_sockaddr_in;
+typedef struct sockaddr_in6 grpc_sockaddr_in6;
+typedef struct in_addr grpc_in_addr;
+typedef struct in6_addr grpc_in6_addr;
+
+#define GRPC_INET_ADDRSTRLEN INET_ADDRSTRLEN
+#define GRPC_INET6_ADDRSTRLEN INET6_ADDRSTRLEN
+
+#define GRPC_SOCK_STREAM SOCK_STREAM
+#define GRPC_SOCK_DGRAM SOCK_DGRAM
+
+#define GRPC_AF_UNSPEC AF_UNSPEC
+#define GRPC_AF_UNIX AF_UNIX
+#define GRPC_AF_INET AF_INET
+#define GRPC_AF_INET6 AF_INET6
+
+#define GRPC_AI_PASSIVE AI_PASSIVE
+
+#endif
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_SOCKADDR_H

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

@@ -22,6 +22,8 @@
 
 #include <string.h>
 
+#include "absl/base/attributes.h"
+
 #define ROTL32(x, r) (((x) << (r)) | ((x) >> (32 - (r))))
 
 #define FMIX32(h)    \
@@ -61,10 +63,10 @@ uint32_t gpr_murmur_hash3(const void* key, size_t len, uint32_t seed) {
   switch (len & 3) {
     case 3:
       k1 ^= (static_cast<uint32_t>(keyptr[2])) << 16;
-    /* fallthrough */
+      ABSL_FALLTHROUGH_INTENDED;
     case 2:
       k1 ^= (static_cast<uint32_t>(keyptr[1])) << 8;
-    /* fallthrough */
+      ABSL_FALLTHROUGH_INTENDED;
     case 1:
       k1 ^= keyptr[0];
       k1 *= c1;

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

@@ -28,7 +28,8 @@
 
 extern "C" {
 #ifdef __linux__
-#if defined(__x86_64__) && !defined(GPR_MUSL_LIBC_COMPAT)
+#if defined(__x86_64__) && !defined(GPR_MUSL_LIBC_COMPAT) && \
+    !defined(__ANDROID__)
 __asm__(".symver memcpy,memcpy@GLIBC_2.2.5");
 void* __wrap_memcpy(void* destination, const void* source, size_t num) {
   return memcpy(destination, source, num);

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

@@ -210,4 +210,4 @@ class ManualConstructor {
 
 }  // namespace grpc_core
 
-#endif
+#endif  // GRPC_CORE_LIB_GPRPP_MANUAL_CONSTRUCTOR_H

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

@@ -72,7 +72,7 @@ inline OrphanablePtr<T> MakeOrphanable(Args&&... args) {
 }
 
 // A type of Orphanable with internal ref-counting.
-template <typename Child>
+template <typename Child, UnrefBehavior UnrefBehaviorArg = kUnrefDelete>
 class InternallyRefCounted : public Orphanable {
  public:
   // Not copyable nor movable.
@@ -102,12 +102,12 @@ class InternallyRefCounted : public Orphanable {
 
   void Unref() {
     if (GPR_UNLIKELY(refs_.Unref())) {
-      delete this;
+      internal::Delete<Child, UnrefBehaviorArg>(static_cast<Child*>(this));
     }
   }
   void Unref(const DebugLocation& location, const char* reason) {
     if (GPR_UNLIKELY(refs_.Unref(location, reason))) {
-      delete this;
+      internal::Delete<Child, UnrefBehaviorArg>(static_cast<Child*>(this));
     }
   }
 

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

@@ -21,8 +21,11 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <vector>
+
 #include "absl/status/status.h"
 #include "absl/time/time.h"
+#include "absl/types/optional.h"
 
 #include "src/core/lib/gprpp/debug_location.h"
 

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

@@ -19,10 +19,9 @@
 #ifndef GRPC_CORE_LIB_GPRPP_SYNC_H
 #define GRPC_CORE_LIB_GPRPP_SYNC_H
 
-#include <grpc/impl/codegen/port_platform.h>
+#include <grpc/support/port_platform.h>
 
-#include <grpc/impl/codegen/log.h>
-#include <grpc/impl/codegen/sync.h>
+#include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
 
@@ -145,33 +144,6 @@ class CondVar {
 
 #endif  // GPR_ABSEIL_SYNC
 
-template <typename Predicate>
-static void WaitUntil(CondVar* cv, Mutex* mu, Predicate pred) {
-  while (!pred()) {
-    cv->Wait(mu);
-  }
-}
-
-// Returns true iff we timed-out
-template <typename Predicate>
-static bool WaitUntilWithTimeout(CondVar* cv, Mutex* mu, Predicate pred,
-                                 absl::Duration timeout) {
-  while (!pred()) {
-    if (cv->WaitWithTimeout(mu, timeout)) return true;
-  }
-  return false;
-}
-
-// Returns true iff we timed-out
-template <typename Predicate>
-static bool WaitUntilWithDeadline(CondVar* cv, Mutex* mu, Predicate pred,
-                                  absl::Time deadline) {
-  while (!pred()) {
-    if (cv->WaitWithDeadline(mu, deadline)) return true;
-  }
-  return false;
-}
-
 // Deprecated. Prefer MutexLock
 class MutexLockForGprMu {
  public:

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

@@ -190,7 +190,7 @@ void extract_opt_stats_from_cmsg(ConnectionMetrics* metrics,
 
 static int get_socket_tcp_info(grpc_core::tcp_info* info, int fd) {
   memset(info, 0, sizeof(*info));
-  info->length = sizeof(*info) - sizeof(socklen_t);
+  info->length = offsetof(grpc_core::tcp_info, length);
   return getsockopt(fd, IPPROTO_TCP, TCP_INFO, info, &(info->length));
 }
 } /* namespace */

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

@@ -0,0 +1,33 @@
+// Copyright 2021 The 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>
+
+#ifdef GRPC_USE_EVENT_ENGINE
+#include "src/core/lib/iomgr/port.h"
+
+#include <stdlib.h>
+
+#include <grpc/support/log.h>
+
+#include "src/core/lib/iomgr/endpoint_pair.h"
+
+grpc_endpoint_pair grpc_iomgr_create_endpoint_pair(
+    const char* /* name */, grpc_channel_args* /* args */) {
+  // TODO(hork): determine what's needed here in the long run
+  GPR_ASSERT(
+      false &&
+      "grpc_iomgr_create_endpoint_pair is not suppoted with event_engine");
+}
+
+#endif  // GRPC_USE_EVENT_ENGINE