grpc 1.61.0 → 1.62.0

data/src/core/lib/iomgr/event_engine_shims/endpoint.cc

@@ -31,7 +31,9 @@
 #include <grpc/support/log.h>
 #include <grpc/support/time.h>
 
-#include "src/core/lib/event_engine/posix.h"
+#include "src/core/lib/event_engine/extensions/can_track_errors.h"
+#include "src/core/lib/event_engine/extensions/supports_fd.h"
+#include "src/core/lib/event_engine/query_extensions.h"
 #include "src/core/lib/event_engine/shim.h"
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
 #include "src/core/lib/event_engine/trace.h"
@@ -217,9 +219,10 @@ class EventEngineEndpointWrapper {
   void ShutdownUnref() {
     if (shutdown_ref_.fetch_sub(1, std::memory_order_acq_rel) ==
         kShutdownBit + 1) {
-      if (EventEngineSupportsFd() && fd_ > 0 && on_release_fd_) {
-        reinterpret_cast<PosixEndpointWithFdSupport*>(endpoint_.get())
-            ->Shutdown(std::move(on_release_fd_));
+      auto* supports_fd =
+          QueryExtension<EndpointSupportsFdExtension>(endpoint_.get());
+      if (supports_fd != nullptr && fd_ > 0 && on_release_fd_) {
+        supports_fd->Shutdown(std::move(on_release_fd_));
       }
       OnShutdownInternal();
     }
@@ -231,7 +234,9 @@ class EventEngineEndpointWrapper {
   // invocation would simply return.
   void TriggerShutdown(
       absl::AnyInvocable<void(absl::StatusOr<int>)> on_release_fd) {
-    if (EventEngineSupportsFd()) {
+    auto* supports_fd =
+        QueryExtension<EndpointSupportsFdExtension>(endpoint_.get());
+    if (supports_fd != nullptr) {
       on_release_fd_ = std::move(on_release_fd);
     }
     int64_t curr = shutdown_ref_.load(std::memory_order_acquire);
@@ -245,9 +250,8 @@ class EventEngineEndpointWrapper {
         Ref();
         if (shutdown_ref_.fetch_sub(1, std::memory_order_acq_rel) ==
             kShutdownBit + 1) {
-          if (EventEngineSupportsFd() && fd_ > 0 && on_release_fd_) {
-            reinterpret_cast<PosixEndpointWithFdSupport*>(endpoint_.get())
-                ->Shutdown(std::move(on_release_fd_));
+          if (supports_fd != nullptr && fd_ > 0 && on_release_fd_) {
+            supports_fd->Shutdown(std::move(on_release_fd_));
           }
           OnShutdownInternal();
         }
@@ -257,9 +261,10 @@ class EventEngineEndpointWrapper {
   }
 
   bool CanTrackErrors() {
-    if (EventEngineSupportsFd()) {
-      return reinterpret_cast<PosixEndpointWithFdSupport*>(endpoint_.get())
-          ->CanTrackErrors();
+    auto* can_track_errors =
+        QueryExtension<EndpointCanTrackErrorsExtension>(endpoint_.get());
+    if (can_track_errors != nullptr) {
+      return can_track_errors->CanTrackErrors();
     } else {
       return false;
     }
@@ -413,9 +418,10 @@ EventEngineEndpointWrapper::EventEngineEndpointWrapper(
       eeep_(std::make_unique<grpc_event_engine_endpoint>()) {
   eeep_->base.vtable = &grpc_event_engine_endpoint_vtable;
   eeep_->wrapper = this;
-  if (EventEngineSupportsFd()) {
-    fd_ = reinterpret_cast<PosixEndpointWithFdSupport*>(endpoint_.get())
-              ->GetWrappedFd();
+  auto* supports_fd =
+      QueryExtension<EndpointSupportsFdExtension>(endpoint_.get());
+  if (supports_fd != nullptr) {
+    fd_ = supports_fd->GetWrappedFd();
   } else {
     fd_ = -1;
   }

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

@@ -39,5 +39,5 @@ uint32_t grpc_if_nametoindex(char* name) {
   return out;
 }
 
-#endif  // GRPC_IF_NAMETOINDEX == 1 && \
-       // defined(GRPC_POSIX_SOCKET_IF_NAMETOINDEX)
+#endif  // GRPC_IF_NAMETOINDEX == 1 &&
+        // defined(GRPC_POSIX_SOCKET_IF_NAMETOINDEX)

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

@@ -35,5 +35,5 @@ uint32_t grpc_if_nametoindex(char* name) {
   return 0;
 }
 
-#endif  // GRPC_IF_NAMETOINDEX == 0 || \
-       // !defined(GRPC_POSIX_SOCKET_IF_NAMETOINDEX)
+#endif  // GRPC_IF_NAMETOINDEX == 0 ||
+        // !defined(GRPC_POSIX_SOCKET_IF_NAMETOINDEX)

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

@@ -58,6 +58,8 @@
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/event_engine/default_event_engine.h"
 #include "src/core/lib/event_engine/memory_allocator_factory.h"
+#include "src/core/lib/event_engine/posix_engine/posix_endpoint.h"
+#include "src/core/lib/event_engine/query_extensions.h"
 #include "src/core/lib/event_engine/resolved_address_internal.h"
 #include "src/core/lib/event_engine/shim.h"
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
@@ -95,7 +97,20 @@ static grpc_error_handle CreateEventEngineListener(
     grpc_tcp_server* s, grpc_closure* shutdown_complete,
     const EndpointConfig& config, grpc_tcp_server** server) {
   absl::StatusOr<std::unique_ptr<EventEngine::Listener>> listener;
-  if (grpc_event_engine::experimental::EventEngineSupportsFd()) {
+  auto* engine = reinterpret_cast<EventEngine*>(
+      config.GetVoidPointer(GRPC_INTERNAL_ARG_EVENT_ENGINE));
+  // Keeps the engine alive for some tests that have not otherwise
+  // instantiated an EventEngine
+  std::shared_ptr<EventEngine> keeper;
+  if (engine == nullptr) {
+    keeper = grpc_event_engine::experimental::GetDefaultEventEngine();
+    engine = keeper.get();
+  }
+  auto* event_engine_supports_fd =
+      grpc_event_engine::experimental::QueryExtension<
+          grpc_event_engine::experimental::EventEngineSupportsFdExtension>(
+          engine);
+  if (event_engine_supports_fd != nullptr) {
     PosixEventEngineWithFdSupport::PosixAcceptCallback accept_cb =
         [s](int listener_fd, std::unique_ptr<EventEngine::Endpoint> ep,
             bool is_external, MemoryAllocator /*allocator*/,
@@ -120,9 +135,10 @@ static grpc_error_handle CreateEventEngineListener(
             memset(&addr, 0, sizeof(addr));
             addr.len = static_cast<socklen_t>(sizeof(struct sockaddr_storage));
             // Get the fd of the socket connected to peer.
-            int fd = reinterpret_cast<grpc_event_engine::experimental::
-                                          PosixEndpointWithFdSupport*>(ep.get())
-                         ->GetWrappedFd();
+            int fd =
+                reinterpret_cast<
+                    grpc_event_engine::experimental::PosixEndpoint*>(ep.get())
+                    ->GetWrappedFd();
             if (getpeername(fd, reinterpret_cast<struct sockaddr*>(addr.addr),
                             &(addr.len)) < 0) {
               gpr_log(GPR_ERROR, "Failed getpeername: %s",
@@ -162,18 +178,7 @@ static grpc_error_handle CreateEventEngineListener(
                               grpc_event_engine_endpoint_create(std::move(ep)),
                           read_notifier_pollset, acceptor);
         };
-    PosixEventEngineWithFdSupport* engine_ptr =
-        reinterpret_cast<PosixEventEngineWithFdSupport*>(
-            config.GetVoidPointer(GRPC_INTERNAL_ARG_EVENT_ENGINE));
-    // Keeps the engine alive for some tests that have not otherwise
-    // instantiated an EventEngine
-    std::shared_ptr<EventEngine> keeper;
-    if (engine_ptr == nullptr) {
-      keeper = grpc_event_engine::experimental::GetDefaultEventEngine();
-      engine_ptr =
-          reinterpret_cast<PosixEventEngineWithFdSupport*>(keeper.get());
-    }
-    listener = engine_ptr->CreatePosixListener(
+    listener = event_engine_supports_fd->CreatePosixListener(
         std::move(accept_cb),
         [s, shutdown_complete](absl::Status status) {
           grpc_event_engine::experimental::RunEventEngineClosure(
@@ -187,15 +192,16 @@ static grpc_error_handle CreateEventEngineListener(
   } else {
     EventEngine::Listener::AcceptCallback accept_cb =
         [s](std::unique_ptr<EventEngine::Endpoint> ep, MemoryAllocator) {
+          grpc_core::ApplicationCallbackExecCtx app_ctx;
+          grpc_core::ExecCtx exec_ctx;
           s->on_accept_cb(s->on_accept_cb_arg,
                           grpc_event_engine::experimental::
                               grpc_event_engine_endpoint_create(std::move(ep)),
                           nullptr, nullptr);
         };
-    auto ee = grpc_event_engine::experimental::GetDefaultEventEngine();
-    listener = ee->CreateListener(
+    listener = engine->CreateListener(
         std::move(accept_cb),
-        [s, ee, shutdown_complete](absl::Status status) {
+        [s, ee = keeper, shutdown_complete](absl::Status status) {
           GPR_ASSERT(gpr_atm_no_barrier_load(&s->refs.count) == 0);
           grpc_event_engine::experimental::RunEventEngineClosure(
               shutdown_complete, absl_status_to_grpc_error(status));
@@ -248,7 +254,7 @@ static grpc_error_handle tcp_server_create(grpc_closure* shutdown_complete,
   s->head = nullptr;
   s->tail = nullptr;
   s->nports = 0;
-  s->options = TcpOptionsFromEndpointConfig(config);
+  s->options = ::TcpOptionsFromEndpointConfig(config);
   s->fd_handler = nullptr;
   GPR_ASSERT(s->options.resource_quota != nullptr);
   GPR_ASSERT(s->on_accept_cb);
@@ -420,10 +426,16 @@ static void on_read(void* arg, grpc_error_handle err) {
       addr.len = static_cast<socklen_t>(sizeof(struct sockaddr_storage));
       if (getpeername(fd, reinterpret_cast<struct sockaddr*>(addr.addr),
                       &(addr.len)) < 0) {
-        gpr_log(GPR_ERROR, "Failed getpeername: %s",
-                grpc_core::StrError(errno).c_str());
+        auto listener_addr_uri = grpc_sockaddr_to_uri(&sp->addr);
+        gpr_log(
+            GPR_ERROR,
+            "Failed getpeername: %s. Dropping the connection, and continuing "
+            "to listen on %s:%d.",
+            grpc_core::StrError(errno).c_str(),
+            listener_addr_uri.ok() ? listener_addr_uri->c_str() : "<unknown>",
+            sp->port);
         close(fd);
-        goto error;
+        continue;
       }
     }
 
@@ -610,22 +622,21 @@ static grpc_error_handle tcp_server_add_port(grpc_tcp_server* s,
     }
     int fd_index = 0;
     absl::StatusOr<int> port;
-    if (grpc_event_engine::experimental::EventEngineSupportsFd()) {
-      port =
-          static_cast<
-              grpc_event_engine::experimental::PosixListenerWithFdSupport*>(
-              s->ee_listener.get())
-              ->BindWithFd(
-                  grpc_event_engine::experimental::CreateResolvedAddress(*addr),
-                  [s, &fd_index](absl::StatusOr<int> listen_fd) {
-                    if (!listen_fd.ok()) {
-                      return;
-                    }
-                    GPR_DEBUG_ASSERT(*listen_fd > 0);
-                    s->listen_fd_to_index_map.insert_or_assign(
-                        *listen_fd,
-                        std::make_tuple(s->n_bind_ports, fd_index++));
-                  });
+    auto* listener_supports_fd =
+        grpc_event_engine::experimental::QueryExtension<
+            grpc_event_engine::experimental::ListenerSupportsFdExtension>(
+            s->ee_listener.get());
+    if (listener_supports_fd != nullptr) {
+      port = listener_supports_fd->BindWithFd(
+          grpc_event_engine::experimental::CreateResolvedAddress(*addr),
+          [s, &fd_index](absl::StatusOr<int> listen_fd) {
+            if (!listen_fd.ok()) {
+              return;
+            }
+            GPR_DEBUG_ASSERT(*listen_fd > 0);
+            s->listen_fd_to_index_map.insert_or_assign(
+                *listen_fd, std::make_tuple(s->n_bind_ports, fd_index++));
+          });
     } else {
       port = s->ee_listener->Bind(
           grpc_event_engine::experimental::CreateResolvedAddress(*addr));
@@ -829,10 +840,12 @@ static void tcp_server_shutdown_listeners(grpc_tcp_server* s) {
   gpr_mu_lock(&s->mu);
   s->shutdown_listeners = true;
   if (grpc_event_engine::experimental::UseEventEngineListener()) {
-    if (grpc_event_engine::experimental::EventEngineSupportsFd()) {
-      static_cast<grpc_event_engine::experimental::PosixListenerWithFdSupport*>(
-          s->ee_listener.get())
-          ->ShutdownListeningFds();
+    auto* listener_supports_fd =
+        grpc_event_engine::experimental::QueryExtension<
+            grpc_event_engine::experimental::ListenerSupportsFdExtension>(
+            s->ee_listener.get());
+    if (listener_supports_fd != nullptr) {
+      listener_supports_fd->ShutdownListeningFds();
     }
   }
   /* shutdown all fd's */
@@ -864,19 +877,21 @@ class ExternalConnectionHandler : public grpc_core::TcpServerFdHandler {
   // TODO(yangg) resolve duplicate code with on_read
   void Handle(int listener_fd, int fd, grpc_byte_buffer* buf) override {
     if (grpc_event_engine::experimental::UseEventEngineListener()) {
-      GPR_ASSERT(grpc_event_engine::experimental::EventEngineSupportsFd());
+      auto* listener_supports_fd =
+          grpc_event_engine::experimental::QueryExtension<
+              grpc_event_engine::experimental::ListenerSupportsFdExtension>(
+              s_->ee_listener.get());
+      GPR_ASSERT(listener_supports_fd != nullptr);
       grpc_event_engine::experimental::SliceBuffer pending_data;
       if (buf != nullptr) {
         pending_data =
             grpc_event_engine::experimental::SliceBuffer::TakeCSliceBuffer(
                 buf->data.raw.slice_buffer);
       }
-      GPR_ASSERT(GRPC_LOG_IF_ERROR(
-          "listener_handle_external_connection",
-          static_cast<
-              grpc_event_engine::experimental::PosixListenerWithFdSupport*>(
-              s_->ee_listener.get())
-              ->HandleExternalConnection(listener_fd, fd, &pending_data)));
+      GPR_ASSERT(
+          GRPC_LOG_IF_ERROR("listener_handle_external_connection",
+                            listener_supports_fd->HandleExternalConnection(
+                                listener_fd, fd, &pending_data)));
       return;
     }
     grpc_pollset* read_notifier_pollset;

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

@@ -89,6 +89,12 @@ static grpc_error_handle get_unused_port(int* port) {
   return *port <= 0 ? GRPC_ERROR_CREATE("Bad port") : absl::OkStatus();
 }
 
+static bool grpc_is_ipv4_availabile() {
+  const int fd = socket(AF_INET, SOCK_DGRAM, 0);
+  if (fd >= 0) close(fd);
+  return fd >= 0;
+}
+
 grpc_error_handle grpc_tcp_server_add_all_local_addrs(grpc_tcp_server* s,
                                                       unsigned port_index,
                                                       int requested_port,
@@ -110,6 +116,9 @@ grpc_error_handle grpc_tcp_server_add_all_local_addrs(grpc_tcp_server* s,
     }
     gpr_log(GPR_DEBUG, "Picked unused port %d", requested_port);
   }
+
+  static bool v4_available = grpc_is_ipv4_availabile();
+
   if (getifaddrs(&ifa) != 0 || ifa == nullptr) {
     return GRPC_OS_ERROR(errno, "getifaddrs");
   }
@@ -121,6 +130,9 @@ grpc_error_handle grpc_tcp_server_add_all_local_addrs(grpc_tcp_server* s,
     if (ifa_it->ifa_addr == nullptr) {
       continue;
     } else if (ifa_it->ifa_addr->sa_family == AF_INET) {
+      if (!v4_available) {
+        continue;
+      }
       addr.len = static_cast<socklen_t>(sizeof(grpc_sockaddr_in));
     } else if (ifa_it->ifa_addr->sa_family == AF_INET6) {
       addr.len = static_cast<socklen_t>(sizeof(grpc_sockaddr_in6));

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

@@ -138,7 +138,7 @@ void JsonWriter::EscapeUtf16(uint16_t utf16) {
   OutputChar(hex[(utf16 >> 12) & 0x0f]);
   OutputChar(hex[(utf16 >> 8) & 0x0f]);
   OutputChar(hex[(utf16 >> 4) & 0x0f]);
-  OutputChar(hex[(utf16)&0x0f]);
+  OutputChar(hex[(utf16) & 0x0f]);
 }
 
 void JsonWriter::EscapeString(const std::string& string) {

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

@@ -282,6 +282,12 @@ class ContextHolder<std::unique_ptr<Context, Deleter>> {
   std::unique_ptr<Context, Deleter> value_;
 };
 
+template <>
+class Context<Activity> {
+ public:
+  static Activity* get() { return Activity::current(); }
+};
+
 template <typename HeldContext>
 using ContextTypeFromHeld = typename ContextHolder<HeldContext>::ContextType;
 
@@ -632,13 +638,13 @@ ActivityPtr MakeActivity(Factory promise_factory,
 }
 
 inline Pending IntraActivityWaiter::pending() {
-  wakeups_ |= Activity::current()->CurrentParticipant();
+  wakeups_ |= GetContext<Activity>()->CurrentParticipant();
   return Pending();
 }
 
 inline void IntraActivityWaiter::Wake() {
   if (wakeups_ == 0) return;
-  Activity::current()->ForceImmediateRepoll(std::exchange(wakeups_, 0));
+  GetContext<Activity>()->ForceImmediateRepoll(std::exchange(wakeups_, 0));
 }
 
 }  // namespace grpc_core

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

@@ -19,8 +19,12 @@
 
 #include <utility>
 
+#include "absl/meta/type_traits.h"
+
 #include <grpc/support/log.h>
 
+#include "src/core/lib/gprpp/down_cast.h"
+
 namespace grpc_core {
 
 // To avoid accidentally creating context types, we require an explicit
@@ -28,17 +32,35 @@ namespace grpc_core {
 // not contain any members, only exist.
 // The reason for avoiding this is that context types each use a thread local.
 template <typename T>
-struct ContextType;  // IWYU pragma: keep
+struct ContextType;
+
+// Some contexts can be subclassed. If the subclass is set as that context
+// then GetContext<Base>() will return the base, and GetContext<Derived>() will
+// down_cast to the derived type.
+// Specializations of this type should be created for each derived type, and
+// should have a single using statement Base pointing to the derived base class.
+// Example:
+//  class SomeContext {};
+//  class SomeDerivedContext : public SomeContext {};
+//  template <> struct ContextType<SomeContext> {};
+//  template <> struct ContextSubclass<SomeDerivedContext> {
+//    using Base = SomeContext;
+//  };
+template <typename Derived>
+struct ContextSubclass;
 
 namespace promise_detail {
 
+template <typename T, typename = void>
+class Context;
+
 template <typename T>
-class Context : public ContextType<T> {
+class ThreadLocalContext : public ContextType<T> {
  public:
-  explicit Context(T* p) : old_(current_) { current_ = p; }
-  ~Context() { current_ = old_; }
-  Context(const Context&) = delete;
-  Context& operator=(const Context&) = delete;
+  explicit ThreadLocalContext(T* p) : old_(current_) { current_ = p; }
+  ~ThreadLocalContext() { current_ = old_; }
+  ThreadLocalContext(const ThreadLocalContext&) = delete;
+  ThreadLocalContext& operator=(const ThreadLocalContext&) = delete;
 
   static T* get() { return current_; }
 
@@ -48,7 +70,23 @@ class Context : public ContextType<T> {
 };
 
 template <typename T>
-thread_local T* Context<T>::current_;
+thread_local T* ThreadLocalContext<T>::current_;
+
+template <typename T>
+class Context<T, absl::void_t<decltype(ContextType<T>())>>
+    : public ThreadLocalContext<T> {
+  using ThreadLocalContext<T>::ThreadLocalContext;
+};
+
+template <typename T>
+class Context<T, absl::void_t<typename ContextSubclass<T>::Base>>
+    : public Context<typename ContextSubclass<T>::Base> {
+ public:
+  using Context<typename ContextSubclass<T>::Base>::Context;
+  static T* get() {
+    return down_cast<T*>(Context<typename ContextSubclass<T>::Base>::get());
+  }
+};
 
 template <typename T, typename F>
 class WithContext {

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

@@ -47,17 +47,14 @@ struct Done;
 
 template <>
 struct Done<absl::Status> {
-  static absl::Status Make() { return absl::OkStatus(); }
+  static absl::Status Make(bool cancelled) {
+    return cancelled ? absl::CancelledError() : absl::OkStatus();
+  }
 };
 
 template <>
 struct Done<StatusFlag> {
-  static StatusFlag Make() { return StatusFlag(true); }
-};
-
-template <>
-struct Done<Success> {
-  static Success Make() { return Success{}; }
+  static StatusFlag Make(bool cancelled) { return StatusFlag(!cancelled); }
 };
 
 template <typename Reader, typename Action>
@@ -118,7 +115,7 @@ class ForEach {
   };
 
   std::string DebugTag() {
-    return absl::StrCat(Activity::current()->DebugTag(), " FOR_EACH[0x",
+    return absl::StrCat(GetContext<Activity>()->DebugTag(), " FOR_EACH[0x",
                         reinterpret_cast<uintptr_t>(this), "]: ");
   }
 
@@ -139,7 +136,7 @@ class ForEach {
         reading_next_ = false;
         return PollAction();
       } else {
-        return Done<Result>::Make();
+        return Done<Result>::Make(p->cancelled());
       }
     }
     return Pending();

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

@@ -86,8 +86,8 @@ class InterceptorList {
   // The result of Run: a promise that will execute the entire chain.
   class RunPromise {
    public:
-    RunPromise(size_t memory_required, Map* factory, absl::optional<T> value) {
-      if (!value.has_value() || factory == nullptr) {
+    RunPromise(size_t memory_required, Map** factory, absl::optional<T> value) {
+      if (!value.has_value() || *factory == nullptr) {
         if (grpc_trace_promise_primitives.enabled()) {
           gpr_log(GPR_DEBUG,
                   "InterceptorList::RunPromise[%p]: create immediate", this);
@@ -97,8 +97,10 @@ class InterceptorList {
       } else {
         is_immediately_resolved_ = false;
         Construct(&async_resolution_, memory_required);
-        factory->MakePromise(std::move(*value), async_resolution_.space.get());
-        async_resolution_.current_factory = factory;
+        (*factory)->MakePromise(std::move(*value),
+                                async_resolution_.space.get());
+        async_resolution_.current_factory = *factory;
+        async_resolution_.first_factory = factory;
         if (grpc_trace_promise_primitives.enabled()) {
           gpr_log(GPR_DEBUG,
                   "InterceptorList::RunPromise[%p]: create async; mem=%p", this,
@@ -147,6 +149,10 @@ class InterceptorList {
       }
       if (is_immediately_resolved_) return std::move(result_);
       while (true) {
+        if (*async_resolution_.first_factory == nullptr) {
+          // Cancelled whilst polling
+          return absl::nullopt;
+        }
         auto r = async_resolution_.current_factory->PollOnce(
             async_resolution_.space.get());
         if (auto* p = r.value_if_ready()) {
@@ -192,8 +198,10 @@ class InterceptorList {
       AsyncResolution& operator=(const AsyncResolution&) = delete;
       AsyncResolution(AsyncResolution&& other) noexcept
           : current_factory(std::exchange(other.current_factory, nullptr)),
+            first_factory(std::exchange(other.first_factory, nullptr)),
             space(std::move(other.space)) {}
       Map* current_factory;
+      Map** first_factory;
       Arena::PoolPtr<char[]> space;
     };
     union {
@@ -212,7 +220,7 @@ class InterceptorList {
   ~InterceptorList() { DeleteFactories(); }
 
   RunPromise Run(absl::optional<T> initial_value) {
-    return RunPromise(promise_memory_required_, first_map_,
+    return RunPromise(promise_memory_required_, &first_map_,
                       std::move(initial_value));
   }
 

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

@@ -113,7 +113,7 @@ class Latch {
 
  private:
   std::string DebugTag() {
-    return absl::StrCat(Activity::current()->DebugTag(), " LATCH[0x",
+    return absl::StrCat(GetContext<Activity>()->DebugTag(), " LATCH[0x",
                         reinterpret_cast<uintptr_t>(this), "]: ");
   }
 
@@ -189,7 +189,7 @@ class Latch<void> {
 
  private:
   std::string DebugTag() {
-    return absl::StrCat(Activity::current()->DebugTag(), " LATCH(void)[0x",
+    return absl::StrCat(GetContext<Activity>()->DebugTag(), " LATCH(void)[0x",
                         reinterpret_cast<uintptr_t>(this), "]: ");
   }
 
@@ -259,7 +259,7 @@ class ExternallyObservableLatch<void> {
 
  private:
   std::string DebugTag() {
-    return absl::StrCat(Activity::current()->DebugTag(), " LATCH(void)[0x",
+    return absl::StrCat(GetContext<Activity>()->DebugTag(), " LATCH(void)[0x",
                         reinterpret_cast<uintptr_t>(this), "]: ");
   }
 

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

@@ -33,6 +33,8 @@
 #include "src/core/lib/iomgr/exec_ctx.h"  // IWYU pragma: keep
 #endif
 
+grpc_core::DebugOnlyTraceFlag grpc_trace_party_state(false, "party_state");
+
 namespace grpc_core {
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -50,12 +52,15 @@ GRPC_MUST_USE_RESULT bool PartySyncUsingAtomics::RefIfNonZero() {
   } while (!state_.compare_exchange_weak(count, count + kOneRef,
                                          std::memory_order_acq_rel,
                                          std::memory_order_relaxed));
+  LogStateChange("RefIfNonZero", count, count + kOneRef);
   return true;
 }
 
 bool PartySyncUsingAtomics::UnreffedLast() {
   uint64_t prev_state =
       state_.fetch_or(kDestroying | kLocked, std::memory_order_acq_rel);
+  LogStateChange("UnreffedLast", prev_state,
+                 prev_state | kDestroying | kLocked);
   return (prev_state & kLocked) == 0;
 }
 
@@ -63,6 +68,8 @@ bool PartySyncUsingAtomics::ScheduleWakeup(WakeupMask mask) {
   // Or in the wakeup bit for the participant, AND the locked bit.
   uint64_t prev_state = state_.fetch_or((mask & kWakeupMask) | kLocked,
                                         std::memory_order_acq_rel);
+  LogStateChange("ScheduleWakeup", prev_state,
+                 prev_state | (mask & kWakeupMask) | kLocked);
   // If the lock was not held now we hold it, so we need to run.
   return ((prev_state & kLocked) == 0);
 }
@@ -269,6 +276,11 @@ void Party::AddParticipants(Participant** participants, size_t count) {
   bool run_party = sync_.AddParticipantsAndRef(count, [this, participants,
                                                        count](size_t* slots) {
     for (size_t i = 0; i < count; i++) {
+      if (grpc_trace_party_state.enabled()) {
+        gpr_log(GPR_DEBUG,
+                "Party %p                 AddParticipant: %s @ %" PRIdPTR,
+                &sync_, std::string(participants[i]->name()).c_str(), slots[i]);
+      }
       participants_[slots[i]].store(participants[i], std::memory_order_release);
     }
   });