grpc 1.48.0 → 1.50.0

data/src/core/lib/service_config/service_config_parser.h

@@ -26,12 +26,10 @@
 #include <utility>
 #include <vector>
 
+#include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
-#include <grpc/support/log.h>
-
-#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/json/json.h"
 
 namespace grpc_core {
@@ -54,21 +52,13 @@ class ServiceConfigParser {
 
     virtual absl::string_view name() const = 0;
 
-    virtual std::unique_ptr<ParsedConfig> ParseGlobalParams(
-        const grpc_channel_args*, const Json& /* json */,
-        grpc_error_handle* error) {
-      // Avoid unused parameter warning on debug-only parameter
-      (void)error;
-      GPR_DEBUG_ASSERT(error != nullptr);
+    virtual absl::StatusOr<std::unique_ptr<ParsedConfig>> ParseGlobalParams(
+        const ChannelArgs& /*args*/, const Json& /*json*/) {
       return nullptr;
     }
 
-    virtual std::unique_ptr<ParsedConfig> ParsePerMethodParams(
-        const grpc_channel_args*, const Json& /* json */,
-        grpc_error_handle* error) {
-      // Avoid unused parameter warning on debug-only parameter
-      (void)error;
-      GPR_DEBUG_ASSERT(error != nullptr);
+    virtual absl::StatusOr<std::unique_ptr<ParsedConfig>> ParsePerMethodParams(
+        const ChannelArgs& /*args*/, const Json& /*json*/) {
       return nullptr;
     }
   };
@@ -90,13 +80,11 @@ class ServiceConfigParser {
     ServiceConfigParserList registered_parsers_;
   };
 
-  ParsedConfigVector ParseGlobalParameters(const grpc_channel_args* args,
-                                           const Json& json,
-                                           grpc_error_handle* error) const;
+  absl::StatusOr<ParsedConfigVector> ParseGlobalParameters(
+      const ChannelArgs& args, const Json& json) const;
 
-  ParsedConfigVector ParsePerMethodParameters(const grpc_channel_args* args,
-                                              const Json& json,
-                                              grpc_error_handle* error) const;
+  absl::StatusOr<ParsedConfigVector> ParsePerMethodParameters(
+      const ChannelArgs& args, const Json& json) const;
 
   // Return the index for a given registered parser.
   // If there is an error, return -1.

data/src/core/lib/slice/percent_encoding.cc

@@ -23,27 +23,18 @@
 #include <stdlib.h>
 
 #include <cstdint>
-#include <type_traits>
 #include <utility>
 
 #include <grpc/support/log.h>
 
 #include "src/core/lib/gprpp/bitset.h"
 
-#if __cplusplus > 201103l
-#define GRPC_PCTENCODE_CONSTEXPR_FN constexpr
-#define GRPC_PCTENCODE_CONSTEXPR_VALUE constexpr
-#else
-#define GRPC_PCTENCODE_CONSTEXPR_FN
-#define GRPC_PCTENCODE_CONSTEXPR_VALUE const
-#endif
-
 namespace grpc_core {
 
 namespace {
 class UrlTable : public BitSet<256> {
  public:
-  GRPC_PCTENCODE_CONSTEXPR_FN UrlTable() {
+  constexpr UrlTable() {
     for (int i = 'a'; i <= 'z'; i++) set(i);
     for (int i = 'A'; i <= 'Z'; i++) set(i);
     for (int i = '0'; i <= '9'; i++) set(i);
@@ -54,11 +45,11 @@ class UrlTable : public BitSet<256> {
   }
 };
 
-GRPC_PCTENCODE_CONSTEXPR_VALUE UrlTable g_url_table;
+constexpr UrlTable g_url_table;
 
 class CompatibleTable : public BitSet<256> {
  public:
-  GRPC_PCTENCODE_CONSTEXPR_FN CompatibleTable() {
+  constexpr CompatibleTable() {
     for (int i = 32; i <= 126; i++) {
       if (i == '%') continue;
       set(i);
@@ -66,7 +57,7 @@ class CompatibleTable : public BitSet<256> {
   }
 };
 
-GRPC_PCTENCODE_CONSTEXPR_VALUE CompatibleTable g_compatible_table;
+constexpr CompatibleTable g_compatible_table;
 
 // Map PercentEncodingType to a lookup table of legal symbols for that encoding.
 const BitSet<256>& LookupTableForPercentEncodingType(PercentEncodingType type) {

data/src/core/lib/slice/slice.cc

@@ -148,6 +148,12 @@ class MovedCppStringSliceRefCount : public grpc_slice_refcount {
   explicit MovedCppStringSliceRefCount(std::string&& str)
       : grpc_slice_refcount(Destroy), str_(std::move(str)) {}
 
+  uint8_t* data() {
+    return reinterpret_cast<uint8_t*>(const_cast<char*>(str_.data()));
+  }
+
+  size_t size() const { return str_.size(); }
+
  private:
   static void Destroy(grpc_slice_refcount* arg) {
     delete static_cast<MovedCppStringSliceRefCount*>(arg);
@@ -206,10 +212,10 @@ grpc_slice grpc_slice_from_cpp_string(std::string str) {
     slice.data.inlined.length = str.size();
     memcpy(GRPC_SLICE_START_PTR(slice), str.data(), str.size());
   } else {
-    slice.data.refcounted.bytes =
-        reinterpret_cast<uint8_t*>(const_cast<char*>(str.data()));
-    slice.data.refcounted.length = str.size();
-    slice.refcount = new grpc_core::MovedCppStringSliceRefCount(std::move(str));
+    auto* refcount = new grpc_core::MovedCppStringSliceRefCount(std::move(str));
+    slice.data.refcounted.bytes = refcount->data();
+    slice.data.refcounted.length = refcount->size();
+    slice.refcount = refcount;
   }
   return slice;
 }

data/src/core/lib/surface/call.cc

@@ -63,7 +63,6 @@
 #include "src/core/lib/iomgr/call_combiner.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/polling_entity.h"
-#include "src/core/lib/profiling/timers.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/slice/slice_internal.h"
@@ -516,8 +515,6 @@ void Call::PublishToParent(Call* parent) {
 
 grpc_error_handle FilterStackCall::Create(grpc_call_create_args* args,
                                           grpc_call** out_call) {
-  GPR_TIMER_SCOPE("grpc_call_create", 0);
-
   Channel* channel = args->channel.get();
 
   auto add_init_error = [](grpc_error_handle* composite,
@@ -643,7 +640,6 @@ void FilterStackCall::ReleaseCall(void* call, grpc_error_handle /*error*/) {
 }
 
 void FilterStackCall::DestroyCall(void* call, grpc_error_handle /*error*/) {
-  GPR_TIMER_SCOPE("destroy_call", 0);
   auto* c = static_cast<FilterStackCall*>(call);
   c->recv_initial_metadata_.Clear();
   c->recv_trailing_metadata_.Clear();
@@ -690,8 +686,6 @@ void Call::MaybeUnpublishFromParent() {
 void FilterStackCall::ExternalUnref() {
   if (GPR_LIKELY(!ext_ref_.Unref())) return;
 
-  GPR_TIMER_SCOPE("grpc_call_unref", 0);
-
   ApplicationCallbackExecCtx callback_exec_ctx;
   ExecCtx exec_ctx;
 
@@ -729,7 +723,6 @@ void FilterStackCall::ExecuteBatch(grpc_transport_stream_op_batch* batch,
   // This is called via the call combiner to start sending a batch down
   // the filter stack.
   auto execute_batch_in_call_combiner = [](void* arg, grpc_error_handle) {
-    GPR_TIMER_SCOPE("execute_batch_in_call_combiner", 0);
     grpc_transport_stream_op_batch* batch =
         static_cast<grpc_transport_stream_op_batch*>(arg);
     auto* call =
@@ -768,6 +761,7 @@ void FilterStackCall::CancelWithError(grpc_error_handle error) {
     GRPC_ERROR_UNREF(error);
     return;
   }
+  gpr_atm_rel_store(&peer_string_, 0);
   InternalRef("termination");
   // Inform the call combiner of the cancellation, so that it can cancel
   // any in-flight asynchronous actions that may be holding the call
@@ -928,7 +922,6 @@ void FilterStackCall::PublishAppMetadata(grpc_metadata_batch* b,
   if (b->count() == 0) return;
   if (!is_client() && is_trailing) return;
   if (is_trailing && buffered_metadata_[1] == nullptr) return;
-  GPR_TIMER_SCOPE("publish_app_metadata", 0);
   grpc_metadata_array* dest;
   dest = buffered_metadata_[is_trailing];
   if (dest->count + b->count() > dest->capacity) {
@@ -1229,7 +1222,6 @@ void FilterStackCall::BatchControl::ReceivingInitialMetadataReady(
     call->RecvInitialFilter(md);
 
     /* TODO(ctiller): this could be moved into recv_initial_filter now */
-    GPR_TIMER_SCOPE("validate_filtered_metadata", 0);
     ValidateFilteredMetadata();
 
     absl::optional<Timestamp> deadline = md->get(GrpcTimeoutMetadata());
@@ -1300,8 +1292,6 @@ void FilterStackCall::BatchControl::FinishBatch(grpc_error_handle error) {
 grpc_call_error FilterStackCall::StartBatch(const grpc_op* ops, size_t nops,
                                             void* notify_tag,
                                             bool is_notify_tag_closure) {
-  GPR_TIMER_SCOPE("call_start_batch", 0);
-
   size_t i;
   const grpc_op* op;
   BatchControl* bctl;
@@ -1415,10 +1405,16 @@ grpc_call_error FilterStackCall::StartBatch(const grpc_op* ops, size_t nops,
         if (is_client() && send_deadline() != Timestamp::InfFuture()) {
           send_initial_metadata_.Set(GrpcTimeoutMetadata(), send_deadline());
         }
+        if (is_client()) {
+          send_initial_metadata_.Set(
+              WaitForReady(),
+              WaitForReady::ValueType{
+                  (op->flags & GRPC_INITIAL_METADATA_WAIT_FOR_READY) != 0,
+                  (op->flags &
+                   GRPC_INITIAL_METADATA_WAIT_FOR_READY_EXPLICITLY_SET) != 0});
+        }
         stream_op_payload->send_initial_metadata.send_initial_metadata =
             &send_initial_metadata_;
-        stream_op_payload->send_initial_metadata.send_initial_metadata_flags =
-            op->flags;
         if (is_client()) {
           stream_op_payload->send_initial_metadata.peer_string = &peer_string_;
         }

data/src/core/lib/surface/channel.cc

@@ -56,13 +56,15 @@
 #include "src/core/lib/surface/call.h"
 #include "src/core/lib/surface/channel_init.h"
 #include "src/core/lib/surface/channel_stack_type.h"
+#include "src/core/lib/surface/init_internally.h"
 #include "src/core/lib/transport/transport.h"
 
 // IWYU pragma: no_include <type_traits>
 
 namespace grpc_core {
 
-Channel::Channel(bool is_client, std::string target, ChannelArgs channel_args,
+Channel::Channel(bool is_client, std::string target,
+                 const ChannelArgs& channel_args,
                  grpc_compression_options compression_options,
                  RefCountedPtr<grpc_channel_stack> channel_stack)
     : is_client_(is_client),
@@ -91,7 +93,7 @@ Channel::Channel(bool is_client, std::string target, ChannelArgs channel_args,
   // accommodate that, we call grpc_init() here and then call
   // grpc_shutdown() when the channel is actually destroyed, thus
   // ensuring that shutdown is deferred until that point.
-  grpc_init();
+  InitInternally();
   auto channelz_node = channelz_node_;
   *channel_stack_->on_destroy = [channelz_node]() {
     if (channelz_node != nullptr) {
@@ -99,7 +101,7 @@ Channel::Channel(bool is_client, std::string target, ChannelArgs channel_args,
           channelz::ChannelTrace::Severity::Info,
           grpc_slice_from_static_string("Channel destroyed"));
     }
-    grpc_shutdown();
+    ShutdownInternally();
   };
 }
 
@@ -149,8 +151,8 @@ absl::StatusOr<RefCountedPtr<Channel>> Channel::CreateWithBuilder(
 
   return RefCountedPtr<Channel>(new Channel(
       grpc_channel_stack_type_is_client(builder->channel_stack_type()),
-      std::string(builder->target()), std::move(channel_args),
-      compression_options, std::move(*r)));
+      std::string(builder->target()), channel_args, compression_options,
+      std::move(*r)));
 }
 
 namespace {
@@ -219,9 +221,8 @@ absl::StatusOr<RefCountedPtr<Channel>> Channel::Create(
       args = channel_args_mutator(target, args, channel_stack_type);
     }
   }
-  builder.SetChannelArgs(std::move(args))
-      .SetTarget(target)
-      .SetTransport(optional_transport);
+  builder.SetChannelArgs(args).SetTarget(target).SetTransport(
+      optional_transport);
   if (!CoreConfiguration::Get().channel_init().CreateStack(&builder)) {
     return nullptr;
   }

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

@@ -154,7 +154,7 @@ class Channel : public RefCounted<Channel>,
   }
 
  private:
-  Channel(bool is_client, std::string target, ChannelArgs channel_args,
+  Channel(bool is_client, std::string target, const ChannelArgs& channel_args,
           grpc_compression_options compression_options,
           RefCountedPtr<grpc_channel_stack> channel_stack);
 

data/src/core/lib/surface/completion_queue.cc

@@ -52,7 +52,6 @@
 #include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/iomgr.h"
 #include "src/core/lib/iomgr/pollset.h"
-#include "src/core/lib/profiling/timers.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/event_string.h"
 
@@ -447,8 +446,6 @@ grpc_core::TraceFlag grpc_cq_pluck_trace(false, "queue_pluck");
 
 static void on_pollset_shutdown_done(void* arg, grpc_error_handle error);
 
-void grpc_cq_global_init() {}
-
 void grpc_completion_queue_thread_local_cache_init(grpc_completion_queue* cq) {
   if (g_cached_cq == nullptr) {
     g_cached_event = nullptr;
@@ -491,17 +488,9 @@ grpc_cq_completion* CqEventQueue::Pop() {
   grpc_cq_completion* c = nullptr;
 
   if (gpr_spinlock_trylock(&queue_lock_)) {
-    GRPC_STATS_INC_CQ_EV_QUEUE_TRYLOCK_SUCCESSES();
-
     bool is_empty = false;
     c = reinterpret_cast<grpc_cq_completion*>(queue_.PopAndCheckEnd(&is_empty));
     gpr_spinlock_unlock(&queue_lock_);
-
-    if (c == nullptr && !is_empty) {
-      GRPC_STATS_INC_CQ_EV_QUEUE_TRANSIENT_POP_FAILURES();
-    }
-  } else {
-    GRPC_STATS_INC_CQ_EV_QUEUE_TRYLOCK_FAILURES();
   }
 
   if (c) {
@@ -514,8 +503,6 @@ grpc_cq_completion* CqEventQueue::Pop() {
 grpc_completion_queue* grpc_completion_queue_create_internal(
     grpc_cq_completion_type completion_type, grpc_cq_polling_type polling_type,
     grpc_completion_queue_functor* shutdown_callback) {
-  GPR_TIMER_SCOPE("grpc_completion_queue_create_internal", 0);
-
   grpc_completion_queue* cq;
 
   GRPC_API_TRACE(
@@ -523,12 +510,23 @@ grpc_completion_queue* grpc_completion_queue_create_internal(
       "polling_type=%d)",
       2, (completion_type, polling_type));
 
+  switch (completion_type) {
+    case GRPC_CQ_NEXT:
+      GRPC_STATS_INC_CQ_NEXT_CREATES();
+      break;
+    case GRPC_CQ_PLUCK:
+      GRPC_STATS_INC_CQ_PLUCK_CREATES();
+      break;
+    case GRPC_CQ_CALLBACK:
+      GRPC_STATS_INC_CQ_CALLBACK_CREATES();
+      break;
+  }
+
   const cq_vtable* vtable = &g_cq_vtable[completion_type];
   const cq_poller_vtable* poller_vtable =
       &g_poller_vtable_by_poller_type[polling_type];
 
   grpc_core::ExecCtx exec_ctx;
-  GRPC_STATS_INC_CQS_CREATED();
 
   cq = static_cast<grpc_completion_queue*>(
       gpr_zalloc(sizeof(grpc_completion_queue) + vtable->data_size +
@@ -692,8 +690,6 @@ static void cq_end_op_for_next(
     grpc_completion_queue* cq, void* tag, grpc_error_handle error,
     void (*done)(void* done_arg, grpc_cq_completion* storage), void* done_arg,
     grpc_cq_completion* storage, bool /*internal*/) {
-  GPR_TIMER_SCOPE("cq_end_op_for_next", 0);
-
   if (GRPC_TRACE_FLAG_ENABLED(grpc_api_trace) ||
       (GRPC_TRACE_FLAG_ENABLED(grpc_trace_operation_failures) &&
        !GRPC_ERROR_IS_NONE(error))) {
@@ -770,8 +766,6 @@ static void cq_end_op_for_pluck(
     grpc_completion_queue* cq, void* tag, grpc_error_handle error,
     void (*done)(void* done_arg, grpc_cq_completion* storage), void* done_arg,
     grpc_cq_completion* storage, bool /*internal*/) {
-  GPR_TIMER_SCOPE("cq_end_op_for_pluck", 0);
-
   cq_pluck_data* cqd = static_cast<cq_pluck_data*> DATA_FROM_CQ(cq);
   int is_success = (GRPC_ERROR_IS_NONE(error));
 
@@ -840,8 +834,6 @@ static void cq_end_op_for_callback(
     grpc_completion_queue* cq, void* tag, grpc_error_handle error,
     void (*done)(void* done_arg, grpc_cq_completion* storage), void* done_arg,
     grpc_cq_completion* storage, bool internal) {
-  GPR_TIMER_SCOPE("cq_end_op_for_callback", 0);
-
   cq_callback_data* cqd = static_cast<cq_callback_data*> DATA_FROM_CQ(cq);
 
   if (GRPC_TRACE_FLAG_ENABLED(grpc_api_trace) ||
@@ -937,7 +929,7 @@ class ExecCtxNext : public grpc_core::ExecCtx {
         return true;
       }
     }
-    return !a->first_loop && a->deadline < grpc_core::ExecCtx::Get()->Now();
+    return !a->first_loop && a->deadline < grpc_core::Timestamp::Now();
   }
 
  private:
@@ -962,8 +954,6 @@ static void dump_pending_tags(grpc_completion_queue* /*cq*/) {}
 
 static grpc_event cq_next(grpc_completion_queue* cq, gpr_timespec deadline,
                           void* reserved) {
-  GPR_TIMER_SCOPE("grpc_completion_queue_next", 0);
-
   grpc_event ret;
   cq_next_data* cqd = static_cast<cq_next_data*> DATA_FROM_CQ(cq);
 
@@ -1043,7 +1033,7 @@ static grpc_event cq_next(grpc_completion_queue* cq, gpr_timespec deadline,
     }
 
     if (!is_finished_arg.first_loop &&
-        grpc_core::ExecCtx::Get()->Now() >= deadline_millis) {
+        grpc_core::Timestamp::Now() >= deadline_millis) {
       ret.type = GRPC_QUEUE_TIMEOUT;
       ret.success = 0;
       dump_pending_tags(cq);
@@ -1198,7 +1188,7 @@ class ExecCtxPluck : public grpc_core::ExecCtx {
       }
       gpr_mu_unlock(cq->mu);
     }
-    return !a->first_loop && a->deadline < grpc_core::ExecCtx::Get()->Now();
+    return !a->first_loop && a->deadline < grpc_core::Timestamp::Now();
   }
 
  private:
@@ -1207,8 +1197,6 @@ class ExecCtxPluck : public grpc_core::ExecCtx {
 
 static grpc_event cq_pluck(grpc_completion_queue* cq, void* tag,
                            gpr_timespec deadline, void* reserved) {
-  GPR_TIMER_SCOPE("grpc_completion_queue_pluck", 0);
-
   grpc_event ret;
   grpc_cq_completion* c;
   grpc_cq_completion* prev;
@@ -1291,7 +1279,7 @@ static grpc_event cq_pluck(grpc_completion_queue* cq, void* tag,
       break;
     }
     if (!is_finished_arg.first_loop &&
-        grpc_core::ExecCtx::Get()->Now() >= deadline_millis) {
+        grpc_core::Timestamp::Now() >= deadline_millis) {
       del_plucker(cq, tag, &worker);
       gpr_mu_unlock(cq->mu);
       ret.type = GRPC_QUEUE_TIMEOUT;
@@ -1414,7 +1402,6 @@ static void cq_shutdown_callback(grpc_completion_queue* cq) {
 /* Shutdown simply drops a ref that we reserved at creation time; if we drop
    to zero here, then enter shutdown mode and wake up any waiters */
 void grpc_completion_queue_shutdown(grpc_completion_queue* cq) {
-  GPR_TIMER_SCOPE("grpc_completion_queue_shutdown", 0);
   grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   GRPC_API_TRACE("grpc_completion_queue_shutdown(cq=%p)", 1, (cq));
@@ -1422,7 +1409,6 @@ void grpc_completion_queue_shutdown(grpc_completion_queue* cq) {
 }
 
 void grpc_completion_queue_destroy(grpc_completion_queue* cq) {
-  GPR_TIMER_SCOPE("grpc_completion_queue_destroy", 0);
   GRPC_API_TRACE("grpc_completion_queue_destroy(cq=%p)", 1, (cq));
   grpc_completion_queue_shutdown(cq);
 

data/src/core/lib/surface/completion_queue.h

@@ -31,7 +31,7 @@
 #include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/gprpp/mpscq.h"
 #include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/iomgr/pollset.h"
+#include "src/core/lib/iomgr/iomgr_fwd.h"
 
 /* These trace flags default to 1. The corresponding lines are only traced
    if grpc_api_trace is also truthy */
@@ -71,9 +71,6 @@ void grpc_cq_internal_unref(grpc_completion_queue* cq);
 #define GRPC_CQ_INTERNAL_UNREF(cq, reason) grpc_cq_internal_unref(cq)
 #endif
 
-/* Initializes global variables used by completion queues */
-void grpc_cq_global_init();
-
 /* Flag that an operation is beginning: the completion channel will not finish
    shutdown until a corrensponding grpc_cq_end_* call is made.
    \a tag is currently used only in debug builds. Return true on success, and

data/src/core/lib/surface/completion_queue_factory.cc

@@ -23,6 +23,7 @@
 #include <grpc/grpc.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/surface/completion_queue.h"
 
 /*
@@ -60,6 +61,7 @@ const grpc_completion_queue_factory* grpc_completion_queue_factory_lookup(
  */
 
 grpc_completion_queue* grpc_completion_queue_create_for_next(void* reserved) {
+  grpc_core::ExecCtx exec_ctx;
   GPR_ASSERT(!reserved);
   grpc_completion_queue_attributes attr = {1, GRPC_CQ_NEXT,
                                            GRPC_CQ_DEFAULT_POLLING, nullptr};
@@ -67,6 +69,7 @@ grpc_completion_queue* grpc_completion_queue_create_for_next(void* reserved) {
 }
 
 grpc_completion_queue* grpc_completion_queue_create_for_pluck(void* reserved) {
+  grpc_core::ExecCtx exec_ctx;
   GPR_ASSERT(!reserved);
   grpc_completion_queue_attributes attr = {1, GRPC_CQ_PLUCK,
                                            GRPC_CQ_DEFAULT_POLLING, nullptr};
@@ -75,6 +78,7 @@ grpc_completion_queue* grpc_completion_queue_create_for_pluck(void* reserved) {
 
 grpc_completion_queue* grpc_completion_queue_create_for_callback(
     grpc_completion_queue_functor* shutdown_callback, void* reserved) {
+  grpc_core::ExecCtx exec_ctx;
   GPR_ASSERT(!reserved);
   grpc_completion_queue_attributes attr = {
       2, GRPC_CQ_CALLBACK, GRPC_CQ_DEFAULT_POLLING, shutdown_callback};
@@ -84,6 +88,7 @@ grpc_completion_queue* grpc_completion_queue_create_for_callback(
 grpc_completion_queue* grpc_completion_queue_create(
     const grpc_completion_queue_factory* factory,
     const grpc_completion_queue_attributes* attr, void* reserved) {
+  grpc_core::ExecCtx exec_ctx;
   GPR_ASSERT(!reserved);
   return factory->vtable->create(factory, attr);
 }

data/src/core/lib/surface/init.cc

@@ -33,19 +33,21 @@
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
 
+#include "src/core/ext/filters/client_channel/backup_poller.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/config/core_configuration.h"
-#include "src/core/lib/debug/stats.h"
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/event_engine/default_event_engine.h"
+#include "src/core/lib/event_engine/forkable.h"
+#include "src/core/lib/event_engine/posix_engine/timer_manager.h"
+#include "src/core/lib/experiments/config.h"
 #include "src/core/lib/gprpp/fork.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/thd.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/iomgr.h"
 #include "src/core/lib/iomgr/timer_manager.h"
-#include "src/core/lib/profiling/timers.h"
 #include "src/core/lib/security/authorization/grpc_server_authz_filter.h"
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/security/security_connector/security_connector.h"
@@ -53,7 +55,7 @@
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/channel_init.h"
 #include "src/core/lib/surface/channel_stack_type.h"
-#include "src/core/lib/surface/completion_queue.h"
+#include "src/core/lib/surface/init_internally.h"
 
 /* (generated) built in registry of plugins */
 extern void grpc_register_built_in_plugins(void);
@@ -116,13 +118,19 @@ void RegisterSecurityFilters(CoreConfiguration::Builder* builder) {
 }  // namespace grpc_core
 
 static void do_basic_init(void) {
+  grpc_core::InitInternally = grpc_init;
+  grpc_core::ShutdownInternally = grpc_shutdown;
   gpr_log_verbosity_init();
   g_init_mu = new grpc_core::Mutex();
   g_shutting_down_cv = new grpc_core::CondVar();
   grpc_register_built_in_plugins();
-  grpc_cq_global_init();
-  grpc_core::grpc_executor_global_init();
   gpr_time_init();
+  grpc_core::PrintExperimentsList();
+  grpc_core::Fork::GlobalInit();
+  grpc_event_engine::experimental::RegisterForkHandlers();
+  grpc_fork_handlers_auto_register();
+  grpc_tracer_init();
+  grpc_client_channel_global_init_backup_polling();
 }
 
 typedef struct grpc_plugin {
@@ -151,18 +159,12 @@ void grpc_init(void) {
       g_shutting_down = false;
       g_shutting_down_cv->SignalAll();
     }
-    grpc_core::Fork::GlobalInit();
-    grpc_fork_handlers_auto_register();
-    grpc_stats_init();
-    grpc_core::ApplicationCallbackExecCtx::GlobalInit();
     grpc_iomgr_init();
-    gpr_timers_global_init();
     for (int i = 0; i < g_number_of_plugins; i++) {
       if (g_all_of_the_plugins[i].init != nullptr) {
         g_all_of_the_plugins[i].init();
       }
     }
-    grpc_tracer_init();
     grpc_iomgr_start();
   }
 
@@ -183,12 +185,9 @@ void grpc_shutdown_internal_locked(void)
         }
       }
     }
+    grpc_event_engine::experimental::ResetDefaultEventEngine();
     grpc_iomgr_shutdown();
-    gpr_timers_global_destroy();
-    grpc_tracer_shutdown();
-    grpc_core::Fork::GlobalShutdown();
   }
-  grpc_core::ApplicationCallbackExecCtx::GlobalShutdown();
   g_shutting_down = false;
   g_shutting_down_cv->SignalAll();
 }
@@ -212,6 +211,8 @@ void grpc_shutdown(void) {
     grpc_core::ApplicationCallbackExecCtx* acec =
         grpc_core::ApplicationCallbackExecCtx::Get();
     if (!grpc_iomgr_is_any_background_poller_thread() &&
+        !grpc_event_engine::posix_engine::TimerManager::
+            IsTimerManagerThread() &&
         (acec == nullptr ||
          (acec->Flags() & GRPC_APP_CALLBACK_EXEC_CTX_FLAG_IS_INTERNAL_THREAD) ==
              0)) {

data/src/core/lib/surface/init_internally.cc

@@ -0,0 +1,24 @@
+// Copyright 2022 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 "src/core/lib/surface/init_internally.h"
+
+namespace grpc_core {
+
+void (*InitInternally)();
+void (*ShutdownInternally)();
+
+}  // namespace grpc_core

data/src/core/lib/surface/init_internally.h

@@ -0,0 +1,28 @@
+// Copyright 2022 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_SURFACE_INIT_INTERNALLY_H
+#define GRPC_CORE_LIB_SURFACE_INIT_INTERNALLY_H
+
+namespace grpc_core {
+
+// Function pointers that should be used in preference to grpc_init,
+// grpc_shutdown from within core, but otherwise do the same thing.
+// Avoids a build dependency cycle between grpc and grpc_base (and friends).
+extern void (*InitInternally)();
+extern void (*ShutdownInternally)();
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_SURFACE_INIT_INTERNALLY_H