grpc 1.58.0.pre1 → 1.59.0

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

@@ -23,6 +23,11 @@
 
 #include <limits>
 
+#if __APPLE__
+// Provides TARGET_OS_IPHONE
+#include <TargetConditionals.h>
+#endif
+
 #include <grpc/impl/grpc_types.h>
 #include <grpc/support/atm.h>
 #include <grpc/support/cpu.h>
@@ -36,6 +41,14 @@
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/closure.h"
 
+#if !defined(_WIN32) || !defined(_DLL)
+#define EXEC_CTX exec_ctx_
+#define CALLBACK_EXEC_CTX callback_exec_ctx_
+#else
+#define EXEC_CTX exec_ctx()
+#define CALLBACK_EXEC_CTX callback_exec_ctx()
+#endif
+
 /// A combiner represents a list of work to be executed later.
 /// Forward declared here to avoid a circular dependency with combiner.h.
 typedef struct grpc_combiner grpc_combiner;
@@ -94,7 +107,7 @@ class Combiner;
 ///               since that implies a core re-entry outside of application
 ///               callbacks.
 ///
-class ExecCtx {
+class GRPC_DLL ExecCtx {
  public:
   /// Default Constructor
 
@@ -125,13 +138,6 @@ class ExecCtx {
   ExecCtx(const ExecCtx&) = delete;
   ExecCtx& operator=(const ExecCtx&) = delete;
 
-  unsigned starting_cpu() {
-    if (starting_cpu_ == std::numeric_limits<unsigned>::max()) {
-      starting_cpu_ = gpr_cpu_current_cpu();
-    }
-    return starting_cpu_;
-  }
-
   struct CombinerData {
     // currently active combiner: updated only via combiner.c
     Combiner* active_combiner;
@@ -176,17 +182,32 @@ class ExecCtx {
     }
   }
 
+  void SetReadyToFinishFlag() { flags_ |= GRPC_EXEC_CTX_FLAG_IS_FINISHED; }
+
   Timestamp Now() { return Timestamp::Now(); }
-  void InvalidateNow() { time_cache_.InvalidateCache(); }
+
+  void InvalidateNow() {
+#if !TARGET_OS_IPHONE
+    time_cache_.InvalidateCache();
+#endif
+  }
+
   void SetNowIomgrShutdown() {
+#if !TARGET_OS_IPHONE
     // We get to do a test only set now on this path just because iomgr
     // is getting removed and no point adding more interfaces for it.
     time_cache_.TestOnlySetNow(Timestamp::InfFuture());
+#endif
+  }
+
+  void TestOnlySetNow(Timestamp now) {
+#if !TARGET_OS_IPHONE
+    time_cache_.TestOnlySetNow(now);
+#endif
   }
-  void TestOnlySetNow(Timestamp now) { time_cache_.TestOnlySetNow(now); }
 
   /// Gets pointer to current exec_ctx.
-  static ExecCtx* Get() { return exec_ctx_; }
+  static ExecCtx* Get() { return EXEC_CTX; }
 
   static void Run(const DebugLocation& location, grpc_closure* closure,
                   grpc_error_handle error);
@@ -201,17 +222,23 @@ class ExecCtx {
   static void operator delete(void* /* p */) { abort(); }
 
  private:
-  /// Set exec_ctx_ to exec_ctx.
-  static void Set(ExecCtx* exec_ctx) { exec_ctx_ = exec_ctx; }
+  /// Set EXEC_CTX to ctx.
+  static void Set(ExecCtx* ctx) { EXEC_CTX = ctx; }
 
   grpc_closure_list closure_list_ = GRPC_CLOSURE_LIST_INIT;
   CombinerData combiner_data_ = {nullptr, nullptr};
   uintptr_t flags_;
 
-  unsigned starting_cpu_ = std::numeric_limits<unsigned>::max();
-
+#if !TARGET_OS_IPHONE
   ScopedTimeCache time_cache_;
+#endif
+
+#if !defined(_WIN32) || !defined(_DLL)
   static thread_local ExecCtx* exec_ctx_;
+#else
+  // cannot be thread_local data member (e.g. exec_ctx_) on windows
+  static ExecCtx*& exec_ctx();
+#endif
   ExecCtx* last_exec_ctx_ = Get();
 };
 
@@ -262,7 +289,7 @@ class ExecCtx {
 ///
 ///
 
-class ApplicationCallbackExecCtx {
+class GRPC_DLL ApplicationCallbackExecCtx {
  public:
   /// Default Constructor
   ApplicationCallbackExecCtx() { Set(this, flags_); }
@@ -282,7 +309,7 @@ class ApplicationCallbackExecCtx {
         }
         (*f->functor_run)(f, f->internal_success);
       }
-      callback_exec_ctx_ = nullptr;
+      CALLBACK_EXEC_CTX = nullptr;
       if (!(GRPC_APP_CALLBACK_EXEC_CTX_FLAG_IS_INTERNAL_THREAD & flags_)) {
         Fork::DecExecCtxCount();
       }
@@ -294,14 +321,14 @@ class ApplicationCallbackExecCtx {
 
   uintptr_t Flags() { return flags_; }
 
-  static ApplicationCallbackExecCtx* Get() { return callback_exec_ctx_; }
+  static ApplicationCallbackExecCtx* Get() { return CALLBACK_EXEC_CTX; }
 
   static void Set(ApplicationCallbackExecCtx* exec_ctx, uintptr_t flags) {
     if (Get() == nullptr) {
       if (!(GRPC_APP_CALLBACK_EXEC_CTX_FLAG_IS_INTERNAL_THREAD & flags)) {
         Fork::IncExecCtxCount();
       }
-      callback_exec_ctx_ = exec_ctx;
+      CALLBACK_EXEC_CTX = exec_ctx;
     }
   }
 
@@ -326,7 +353,13 @@ class ApplicationCallbackExecCtx {
   uintptr_t flags_{0u};
   grpc_completion_queue_functor* head_{nullptr};
   grpc_completion_queue_functor* tail_{nullptr};
+
+#if !defined(_WIN32) || !defined(_DLL)
   static thread_local ApplicationCallbackExecCtx* callback_exec_ctx_;
+#else
+  // cannot be thread_local data member (e.g. callback_exec_ctx_) on windows
+  static ApplicationCallbackExecCtx*& callback_exec_ctx();
+#endif
 };
 
 template <typename F>
@@ -340,6 +373,9 @@ void EnsureRunInExecCtx(F f) {
   }
 }
 
+#undef EXEC_CTX
+#undef CALLBACK_EXEC_CTX
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_IOMGR_EXEC_CTX_H

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

@@ -98,3 +98,13 @@ void grpc_polling_entity_del_from_pollset_set(grpc_polling_entity* pollent,
         absl::StrFormat("Invalid grpc_polling_entity tag '%d'", pollent->tag));
   }
 }
+
+std::string grpc_polling_entity_string(grpc_polling_entity* pollent) {
+  if (pollent->tag == GRPC_POLLS_POLLSET) {
+    return absl::StrFormat("pollset:%p", pollent->pollent.pollset);
+  } else if (pollent->tag == GRPC_POLLS_POLLSET_SET) {
+    return absl::StrFormat("pollset_set:%p", pollent->pollent.pollset_set);
+  } else {
+    return absl::StrFormat("invalid_tag:%d", pollent->tag);
+  }
+}

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

@@ -66,6 +66,8 @@ void grpc_polling_entity_add_to_pollset_set(grpc_polling_entity* pollent,
 void grpc_polling_entity_del_from_pollset_set(grpc_polling_entity* pollent,
                                               grpc_pollset_set* pss_dst);
 
+std::string grpc_polling_entity_string(grpc_polling_entity* pollent);
+
 namespace grpc_core {
 template <>
 struct ContextType<grpc_polling_entity> {};

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

@@ -209,6 +209,20 @@
 #define GRPC_POSIX_SOCKET 1
 #define GRPC_POSIX_SOCKETUTILS 1
 #define GRPC_POSIX_WAKEUP_FD 1
+#elif defined(__QNX__) || defined(__QNXNTO__)
+#define GRPC_HAVE_ARPA_NAMESER 1
+#define GRPC_HAVE_IFADDRS 1
+#define GRPC_HAVE_IPV6_RECVPKTINFO 1
+#define GRPC_HAVE_IP_PKTINFO 1
+#define GRPC_HAVE_MSG_NOSIGNAL 1
+#define GRPC_HAVE_UNIX_SOCKET 1
+// TODO(rbyshliaha): Find a way to understand if VSOCK package is installed in
+//                   a toolchain to enable GRPC_HAVE_VSOCK.
+#define GRPC_POSIX_SOCKET 1
+#define GRPC_POSIX_WAKEUP_FD 1
+#define GRPC_POSIX_NO_SPECIAL_WAKEUP_FD 1
+#define GRPC_POSIX_SOCKETUTILS 1
+#define GRPC_POSIX_SYSCONF 1
 #elif !defined(GPR_NO_AUTODETECT_PLATFORM)
 #error "Platform not recognized"
 #endif

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

@@ -459,7 +459,7 @@ class TcpZerocopySendCtx {
   std::unordered_map<uint32_t, TcpZerocopySendRecord*> ctx_lookup_;
   bool memory_limited_ = false;
   bool is_in_write_ = false;
-  OMemState zcopy_enobuf_state_;
+  OMemState zcopy_enobuf_state_ = OMemState::OPEN;
 };
 
 }  // namespace grpc_core
@@ -479,10 +479,7 @@ struct grpc_tcp {
   grpc_endpoint base;
   grpc_fd* em_fd;
   int fd;
-  // Used by the endpoint read function to distinguish the very first read call
-  // from the rest
-  bool is_first_read;
-  bool has_posted_reclaimer ABSL_GUARDED_BY(read_mu) = false;
+  int inq;  // bytes pending on the socket from the last read.
   double target_length;
   double bytes_read_this_round;
   grpc_core::RefCount refcount;
@@ -490,15 +487,12 @@ struct grpc_tcp {
 
   int min_read_chunk_size;
   int max_read_chunk_size;
-  int set_rcvlowat = 0;
 
   // garbage after the last read
   grpc_slice_buffer last_read_buffer;
 
   grpc_core::Mutex read_mu;
   grpc_slice_buffer* incoming_buffer ABSL_GUARDED_BY(read_mu) = nullptr;
-  int inq;           // bytes pending on the socket from the last read.
-  bool inq_capable;  // cache whether kernel supports inq
 
   grpc_slice_buffer* outgoing_buffer;
   // byte within outgoing_buffer->slices[0] to write next
@@ -535,17 +529,26 @@ struct grpc_tcp {
   // options for collecting timestamps are set, and is incremented with each
   // byte sent.
   int bytes_counter;
-  bool socket_ts_enabled;  // True if timestamping options are set on the socket
-                           //
-  bool ts_capable;         // Cache whether we can set timestamping options
+
+  int min_progress_size;  // A hint from upper layers specifying the minimum
+                          // number of bytes that need to be read to make
+                          // meaningful progress
+
   gpr_atm stop_error_notification;  // Set to 1 if we do not want to be notified
                                     // on errors anymore
   TcpZerocopySendCtx tcp_zerocopy_send_ctx;
   TcpZerocopySendRecord* current_zerocopy_send = nullptr;
 
-  int min_progress_size;  // A hint from upper layers specifying the minimum
-                          // number of bytes that need to be read to make
-                          // meaningful progress
+  int set_rcvlowat = 0;
+
+  // Used by the endpoint read function to distinguish the very first read call
+  // from the rest
+  bool is_first_read;
+  bool has_posted_reclaimer ABSL_GUARDED_BY(read_mu) = false;
+  bool inq_capable;        // cache whether kernel supports inq
+  bool socket_ts_enabled;  // True if timestamping options are set on the socket
+                           //
+  bool ts_capable;         // Cache whether we can set timestamping options
 };
 
 struct backup_poller {

data/src/core/lib/load_balancing/lb_policy.h

@@ -148,6 +148,14 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
     /// The LB policy may use the existing metadata to influence its routing
     /// decision, and it may add new metadata elements to be sent with the
     /// call to the chosen backend.
+    // TODO(roth): Before making the LB policy API public, consider
+    // whether this is the right way to expose metadata to the picker.
+    // This approach means that if a pick modifies metadata but then we
+    // discard the pick because the subchannel is not connected, the
+    // metadata change will still have been made.  Maybe we actually
+    // want to somehow provide metadata changes in PickResult::Complete
+    // instead?  Or maybe we use a CallTracer that can add metadata when
+    // the call actually starts on the subchannel?
     MetadataInterface* initial_metadata;
     /// An interface for accessing call state.  Can be used to allocate
     /// memory associated with the call in an efficient way.
@@ -168,6 +176,8 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
 
   /// Interface for tracking subchannel calls.
   /// Implemented by LB policy and used by the channel.
+  // TODO(roth): Before making this API public, consider whether we
+  // should just replace this with a CallTracer, similar to what Java does.
   class SubchannelCallTrackerInterface {
    public:
     virtual ~SubchannelCallTrackerInterface() = default;
@@ -257,10 +267,6 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
   /// state and logic needed on the control plane (i.e., resolver
   /// updates, connectivity state notifications, etc); the latter should
   /// live in the LB policy object itself.
-  ///
-  /// Currently, pickers are always accessed from within the
-  /// client_channel data plane mutex, so they do not have to be
-  /// thread-safe.
   class SubchannelPicker : public DualRefCounted<SubchannelPicker> {
    public:
     SubchannelPicker();
@@ -272,11 +278,6 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
 
   /// A proxy object implemented by the client channel and used by the
   /// LB policy to communicate with the channel.
-  // TODO(roth): Once insecure builds go away, add methods for accessing
-  // channel creds.  By default, that should strip off the call creds
-  // attached to the channel creds, but there should also be a "use at
-  // your own risk" option to get the channel creds without stripping
-  // off the attached call creds.
   class ChannelControlHelper {
    public:
     ChannelControlHelper() = default;

data/src/core/lib/promise/arena_promise.h

@@ -19,6 +19,7 @@
 
 #include <stdlib.h>
 
+#include <cstddef>
 #include <memory>
 #include <type_traits>
 #include <utility>
@@ -34,7 +35,10 @@ namespace grpc_core {
 
 namespace arena_promise_detail {
 
-using ArgType = std::aligned_storage_t<sizeof(void*)>;
+struct ArgType {
+  alignas(std::max_align_t) char buffer[sizeof(void*)];
+};
+
 template <typename T>
 T*& ArgAsPtr(ArgType* arg) {
   static_assert(sizeof(ArgType) >= sizeof(T**),