grpc 1.19.0 → 1.20.0.pre1

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

@@ -33,6 +33,7 @@
 #include "src/core/lib/debug/stats.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/fork.h"
+#include "src/core/lib/gprpp/mutex_lock.h"
 #include "src/core/lib/http/parser.h"
 #include "src/core/lib/iomgr/call_combiner.h"
 #include "src/core/lib/iomgr/combiner.h"
@@ -61,10 +62,15 @@ extern void grpc_register_built_in_plugins(void);
 static gpr_once g_basic_init = GPR_ONCE_INIT;
 static gpr_mu g_init_mu;
 static int g_initializations;
+static gpr_cv* g_shutting_down_cv;
+static bool g_shutting_down;
 
 static void do_basic_init(void) {
   gpr_log_verbosity_init();
   gpr_mu_init(&g_init_mu);
+  g_shutting_down_cv = static_cast<gpr_cv*>(malloc(sizeof(gpr_cv)));
+  gpr_cv_init(g_shutting_down_cv);
+  g_shutting_down = false;
   grpc_register_built_in_plugins();
   grpc_cq_global_init();
   g_initializations = 0;
@@ -118,8 +124,12 @@ void grpc_init(void) {
   int i;
   gpr_once_init(&g_basic_init, do_basic_init);
 
-  gpr_mu_lock(&g_init_mu);
+  grpc_core::MutexLock lock(&g_init_mu);
   if (++g_initializations == 1) {
+    if (g_shutting_down) {
+      g_shutting_down = false;
+      gpr_cv_broadcast(g_shutting_down_cv);
+    }
     grpc_core::Fork::GlobalInit();
     grpc_fork_handlers_auto_register();
     gpr_time_init();
@@ -150,50 +160,88 @@ void grpc_init(void) {
     grpc_channel_init_finalize();
     grpc_iomgr_start();
   }
-  gpr_mu_unlock(&g_init_mu);
 
   GRPC_API_TRACE("grpc_init(void)", 0, ());
 }
 
-void grpc_shutdown(void) {
+void grpc_shutdown_internal_locked(void) {
   int i;
-  GRPC_API_TRACE("grpc_shutdown(void)", 0, ());
-  gpr_mu_lock(&g_init_mu);
-  if (--g_initializations == 0) {
+  {
+    grpc_core::ExecCtx exec_ctx(0);
+    grpc_iomgr_shutdown_background_closure();
     {
-      grpc_core::ExecCtx exec_ctx(0);
-      grpc_iomgr_shutdown_background_closure();
-      {
-        grpc_timer_manager_set_threading(
-            false);  // shutdown timer_manager thread
-        grpc_core::Executor::ShutdownAll();
-        for (i = g_number_of_plugins; i >= 0; i--) {
-          if (g_all_of_the_plugins[i].destroy != nullptr) {
-            g_all_of_the_plugins[i].destroy();
-          }
+      grpc_timer_manager_set_threading(false);  // shutdown timer_manager thread
+      grpc_core::Executor::ShutdownAll();
+      for (i = g_number_of_plugins; i >= 0; i--) {
+        if (g_all_of_the_plugins[i].destroy != nullptr) {
+          g_all_of_the_plugins[i].destroy();
         }
       }
-      grpc_iomgr_shutdown();
-      gpr_timers_global_destroy();
-      grpc_tracer_shutdown();
-      grpc_mdctx_global_shutdown();
-      grpc_core::HandshakerRegistry::Shutdown();
-      grpc_slice_intern_shutdown();
-      grpc_core::channelz::ChannelzRegistry::Shutdown();
-      grpc_stats_shutdown();
-      grpc_core::Fork::GlobalShutdown();
     }
-    grpc_core::ExecCtx::GlobalShutdown();
-    grpc_core::ApplicationCallbackExecCtx::GlobalShutdown();
+    grpc_iomgr_shutdown();
+    gpr_timers_global_destroy();
+    grpc_tracer_shutdown();
+    grpc_mdctx_global_shutdown();
+    grpc_core::HandshakerRegistry::Shutdown();
+    grpc_slice_intern_shutdown();
+    grpc_core::channelz::ChannelzRegistry::Shutdown();
+    grpc_stats_shutdown();
+    grpc_core::Fork::GlobalShutdown();
+  }
+  grpc_core::ExecCtx::GlobalShutdown();
+  grpc_core::ApplicationCallbackExecCtx::GlobalShutdown();
+  g_shutting_down = false;
+  gpr_cv_broadcast(g_shutting_down_cv);
+}
+
+void grpc_shutdown_internal(void* ignored) {
+  GRPC_API_TRACE("grpc_shutdown_internal", 0, ());
+  grpc_core::MutexLock lock(&g_init_mu);
+  // We have released lock from the shutdown thread and it is possible that
+  // another grpc_init has been called, and do nothing if that is the case.
+  if (--g_initializations != 0) {
+    return;
+  }
+  grpc_shutdown_internal_locked();
+}
+
+void grpc_shutdown(void) {
+  GRPC_API_TRACE("grpc_shutdown(void)", 0, ());
+  grpc_core::MutexLock lock(&g_init_mu);
+  if (--g_initializations == 0) {
+    g_initializations++;
+    g_shutting_down = true;
+    // spawn a detached thread to do the actual clean up in case we are
+    // currently in an executor thread.
+    grpc_core::Thread cleanup_thread(
+        "grpc_shutdown", grpc_shutdown_internal, nullptr, nullptr,
+        grpc_core::Thread::Options().set_joinable(false).set_tracked(false));
+    cleanup_thread.Start();
+  }
+}
+
+void grpc_shutdown_blocking(void) {
+  GRPC_API_TRACE("grpc_shutdown_blocking(void)", 0, ());
+  grpc_core::MutexLock lock(&g_init_mu);
+  if (--g_initializations == 0) {
+    g_shutting_down = true;
+    grpc_shutdown_internal_locked();
   }
-  gpr_mu_unlock(&g_init_mu);
 }
 
 int grpc_is_initialized(void) {
   int r;
   gpr_once_init(&g_basic_init, do_basic_init);
-  gpr_mu_lock(&g_init_mu);
+  grpc_core::MutexLock lock(&g_init_mu);
   r = g_initializations > 0;
-  gpr_mu_unlock(&g_init_mu);
   return r;
 }
+
+void grpc_maybe_wait_for_async_shutdown(void) {
+  gpr_once_init(&g_basic_init, do_basic_init);
+  grpc_core::MutexLock lock(&g_init_mu);
+  while (g_shutting_down) {
+    gpr_cv_wait(g_shutting_down_cv, &g_init_mu,
+                gpr_inf_future(GPR_CLOCK_REALTIME));
+  }
+}

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

@@ -22,5 +22,6 @@
 void grpc_register_security_filters(void);
 void grpc_security_pre_init(void);
 void grpc_security_init(void);
+void grpc_maybe_wait_for_async_shutdown(void);
 
 #endif /* GRPC_CORE_LIB_SURFACE_INIT_H */

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

@@ -25,10 +25,9 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include "src/core/lib/gprpp/atomic.h"
-
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gprpp/atomic.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/call.h"
 #include "src/core/lib/surface/channel.h"
@@ -43,7 +42,7 @@ struct CallData {
   grpc_call_combiner* call_combiner;
   grpc_linked_mdelem status;
   grpc_linked_mdelem details;
-  grpc_core::atomic<bool> filled_metadata;
+  grpc_core::Atomic<bool> filled_metadata;
 };
 
 struct ChannelData {
@@ -54,9 +53,8 @@ struct ChannelData {
 static void fill_metadata(grpc_call_element* elem, grpc_metadata_batch* mdb) {
   CallData* calld = static_cast<CallData*>(elem->call_data);
   bool expected = false;
-  if (!calld->filled_metadata.compare_exchange_strong(
-          expected, true, grpc_core::memory_order_relaxed,
-          grpc_core::memory_order_relaxed)) {
+  if (!calld->filled_metadata.CompareExchangeStrong(
+          &expected, true, MemoryOrder::RELAXED, MemoryOrder::RELAXED)) {
     return;
   }
   ChannelData* chand = static_cast<ChannelData*>(elem->channel_data);

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

@@ -25,4 +25,4 @@
 
 const char* grpc_version_string(void) { return "7.0.0"; }
 
-const char* grpc_g_stands_for(void) { return "gold"; }
+const char* grpc_g_stands_for(void) { return "godric"; }

data/src/core/lib/transport/metadata.cc

@@ -71,6 +71,12 @@ grpc_core::DebugOnlyTraceFlag grpc_trace_metadata(false, "metadata");
 
 typedef void (*destroy_user_data_func)(void* user_data);
 
+struct UserData {
+  gpr_mu mu_user_data;
+  gpr_atm destroy_user_data;
+  gpr_atm user_data;
+};
+
 /* Shadow structure for grpc_mdelem_data for interned elements */
 typedef struct interned_metadata {
   /* must be byte compatible with grpc_mdelem_data */
@@ -80,9 +86,7 @@ typedef struct interned_metadata {
   /* private only data */
   gpr_atm refcnt;
 
-  gpr_mu mu_user_data;
-  gpr_atm destroy_user_data;
-  gpr_atm user_data;
+  UserData user_data;
 
   struct interned_metadata* bucket_next;
 } interned_metadata;
@@ -95,6 +99,8 @@ typedef struct allocated_metadata {
 
   /* private only data */
   gpr_atm refcnt;
+
+  UserData user_data;
 } allocated_metadata;
 
 typedef struct mdtab_shard {
@@ -178,16 +184,17 @@ static void gc_mdtab(mdtab_shard* shard) {
   for (i = 0; i < shard->capacity; i++) {
     prev_next = &shard->elems[i];
     for (md = shard->elems[i]; md; md = next) {
-      void* user_data = (void*)gpr_atm_no_barrier_load(&md->user_data);
+      void* user_data =
+          (void*)gpr_atm_no_barrier_load(&md->user_data.user_data);
       next = md->bucket_next;
       if (gpr_atm_acq_load(&md->refcnt) == 0) {
         grpc_slice_unref_internal(md->key);
         grpc_slice_unref_internal(md->value);
-        if (md->user_data) {
+        if (md->user_data.user_data) {
           ((destroy_user_data_func)gpr_atm_no_barrier_load(
-              &md->destroy_user_data))(user_data);
+              &md->user_data.destroy_user_data))(user_data);
         }
-        gpr_mu_destroy(&md->mu_user_data);
+        gpr_mu_destroy(&md->user_data.mu_user_data);
         gpr_free(md);
         *prev_next = next;
         num_freed++;
@@ -251,6 +258,9 @@ grpc_mdelem grpc_mdelem_create(
     allocated->key = grpc_slice_ref_internal(key);
     allocated->value = grpc_slice_ref_internal(value);
     gpr_atm_rel_store(&allocated->refcnt, 1);
+    allocated->user_data.user_data = 0;
+    allocated->user_data.destroy_user_data = 0;
+    gpr_mu_init(&allocated->user_data.mu_user_data);
 #ifndef NDEBUG
     if (grpc_trace_metadata.enabled()) {
       char* key_str = grpc_slice_to_c_string(allocated->key);
@@ -299,11 +309,11 @@ grpc_mdelem grpc_mdelem_create(
   gpr_atm_rel_store(&md->refcnt, 1);
   md->key = grpc_slice_ref_internal(key);
   md->value = grpc_slice_ref_internal(value);
-  md->user_data = 0;
-  md->destroy_user_data = 0;
+  md->user_data.user_data = 0;
+  md->user_data.destroy_user_data = 0;
   md->bucket_next = shard->elems[idx];
   shard->elems[idx] = md;
-  gpr_mu_init(&md->mu_user_data);
+  gpr_mu_init(&md->user_data.mu_user_data);
 #ifndef NDEBUG
   if (grpc_trace_metadata.enabled()) {
     char* key_str = grpc_slice_to_c_string(md->key);
@@ -450,6 +460,13 @@ void grpc_mdelem_unref(grpc_mdelem gmd DEBUG_ARGS) {
       if (1 == prev_refcount) {
         grpc_slice_unref_internal(md->key);
         grpc_slice_unref_internal(md->value);
+        if (md->user_data.user_data) {
+          destroy_user_data_func destroy_user_data =
+              (destroy_user_data_func)gpr_atm_no_barrier_load(
+                  &md->user_data.destroy_user_data);
+          destroy_user_data((void*)md->user_data.user_data);
+        }
+        gpr_mu_destroy(&md->user_data.mu_user_data);
         gpr_free(md);
       }
       break;
@@ -457,58 +474,74 @@ void grpc_mdelem_unref(grpc_mdelem gmd DEBUG_ARGS) {
   }
 }
 
+static void* get_user_data(UserData* user_data, void (*destroy_func)(void*)) {
+  if (gpr_atm_acq_load(&user_data->destroy_user_data) ==
+      (gpr_atm)destroy_func) {
+    return (void*)gpr_atm_no_barrier_load(&user_data->user_data);
+  } else {
+    return nullptr;
+  }
+}
+
 void* grpc_mdelem_get_user_data(grpc_mdelem md, void (*destroy_func)(void*)) {
   switch (GRPC_MDELEM_STORAGE(md)) {
     case GRPC_MDELEM_STORAGE_EXTERNAL:
-    case GRPC_MDELEM_STORAGE_ALLOCATED:
       return nullptr;
     case GRPC_MDELEM_STORAGE_STATIC:
       return (void*)grpc_static_mdelem_user_data[GRPC_MDELEM_DATA(md) -
                                                  grpc_static_mdelem_table];
+    case GRPC_MDELEM_STORAGE_ALLOCATED: {
+      allocated_metadata* am =
+          reinterpret_cast<allocated_metadata*>(GRPC_MDELEM_DATA(md));
+      return get_user_data(&am->user_data, destroy_func);
+    }
     case GRPC_MDELEM_STORAGE_INTERNED: {
       interned_metadata* im =
           reinterpret_cast<interned_metadata*> GRPC_MDELEM_DATA(md);
-      void* result;
-      if (gpr_atm_acq_load(&im->destroy_user_data) == (gpr_atm)destroy_func) {
-        return (void*)gpr_atm_no_barrier_load(&im->user_data);
-      } else {
-        return nullptr;
-      }
-      return result;
+      return get_user_data(&im->user_data, destroy_func);
     }
   }
   GPR_UNREACHABLE_CODE(return nullptr);
 }
 
+static void* set_user_data(UserData* ud, void (*destroy_func)(void*),
+                           void* user_data) {
+  GPR_ASSERT((user_data == nullptr) == (destroy_func == nullptr));
+  gpr_mu_lock(&ud->mu_user_data);
+  if (gpr_atm_no_barrier_load(&ud->destroy_user_data)) {
+    /* user data can only be set once */
+    gpr_mu_unlock(&ud->mu_user_data);
+    if (destroy_func != nullptr) {
+      destroy_func(user_data);
+    }
+    return (void*)gpr_atm_no_barrier_load(&ud->user_data);
+  }
+  gpr_atm_no_barrier_store(&ud->user_data, (gpr_atm)user_data);
+  gpr_atm_rel_store(&ud->destroy_user_data, (gpr_atm)destroy_func);
+  gpr_mu_unlock(&ud->mu_user_data);
+  return user_data;
+}
+
 void* grpc_mdelem_set_user_data(grpc_mdelem md, void (*destroy_func)(void*),
                                 void* user_data) {
   switch (GRPC_MDELEM_STORAGE(md)) {
     case GRPC_MDELEM_STORAGE_EXTERNAL:
-    case GRPC_MDELEM_STORAGE_ALLOCATED:
       destroy_func(user_data);
       return nullptr;
     case GRPC_MDELEM_STORAGE_STATIC:
       destroy_func(user_data);
       return (void*)grpc_static_mdelem_user_data[GRPC_MDELEM_DATA(md) -
                                                  grpc_static_mdelem_table];
+    case GRPC_MDELEM_STORAGE_ALLOCATED: {
+      allocated_metadata* am =
+          reinterpret_cast<allocated_metadata*>(GRPC_MDELEM_DATA(md));
+      return set_user_data(&am->user_data, destroy_func, user_data);
+    }
     case GRPC_MDELEM_STORAGE_INTERNED: {
       interned_metadata* im =
           reinterpret_cast<interned_metadata*> GRPC_MDELEM_DATA(md);
       GPR_ASSERT(!is_mdelem_static(md));
-      GPR_ASSERT((user_data == nullptr) == (destroy_func == nullptr));
-      gpr_mu_lock(&im->mu_user_data);
-      if (gpr_atm_no_barrier_load(&im->destroy_user_data)) {
-        /* user data can only be set once */
-        gpr_mu_unlock(&im->mu_user_data);
-        if (destroy_func != nullptr) {
-          destroy_func(user_data);
-        }
-        return (void*)gpr_atm_no_barrier_load(&im->user_data);
-      }
-      gpr_atm_no_barrier_store(&im->user_data, (gpr_atm)user_data);
-      gpr_atm_rel_store(&im->destroy_user_data, (gpr_atm)destroy_func);
-      gpr_mu_unlock(&im->mu_user_data);
-      return user_data;
+      return set_user_data(&im->user_data, destroy_func, user_data);
     }
   }
   GPR_UNREACHABLE_CODE(return nullptr);

data/src/core/lib/transport/metadata_batch.cc

@@ -227,7 +227,7 @@ void grpc_metadata_batch_remove(grpc_metadata_batch* batch,
 }
 
 void grpc_metadata_batch_set_value(grpc_linked_mdelem* storage,
-                                   grpc_slice value) {
+                                   const grpc_slice& value) {
   grpc_mdelem old_mdelem = storage->md;
   grpc_mdelem new_mdelem = grpc_mdelem_from_slices(
       grpc_slice_ref_internal(GRPC_MDKEY(old_mdelem)), value);

data/src/core/lib/transport/metadata_batch.h

@@ -74,7 +74,7 @@ grpc_error* grpc_metadata_batch_substitute(grpc_metadata_batch* batch,
                                            grpc_mdelem new_value);
 
 void grpc_metadata_batch_set_value(grpc_linked_mdelem* storage,
-                                   grpc_slice value);
+                                   const grpc_slice& value);
 
 /** Add \a storage to the beginning of \a batch. storage->md is
     assumed to be valid.

data/src/core/lib/transport/timeout_encoding.cc

@@ -89,7 +89,7 @@ static int is_all_whitespace(const char* p, const char* end) {
   return p == end;
 }
 
-int grpc_http2_decode_timeout(grpc_slice text, grpc_millis* timeout) {
+int grpc_http2_decode_timeout(const grpc_slice& text, grpc_millis* timeout) {
   grpc_millis x = 0;
   const uint8_t* p = GRPC_SLICE_START_PTR(text);
   const uint8_t* end = GRPC_SLICE_END_PTR(text);

data/src/core/lib/transport/timeout_encoding.h

@@ -32,6 +32,6 @@
 /* Encode/decode timeouts to the GRPC over HTTP/2 format;
    encoding may round up arbitrarily */
 void grpc_http2_encode_timeout(grpc_millis timeout, char* buffer);
-int grpc_http2_decode_timeout(grpc_slice text, grpc_millis* timeout);
+int grpc_http2_decode_timeout(const grpc_slice& text, grpc_millis* timeout);
 
 #endif /* GRPC_CORE_LIB_TRANSPORT_TIMEOUT_ENCODING_H */

data/src/core/lib/transport/transport.h

@@ -111,10 +111,11 @@ void grpc_transport_move_stats(grpc_transport_stream_stats* from,
 // currently handling the batch).  Once a filter or transport passes control
 // of the batch to the next handler, it cannot depend on the contents of
 // this struct anymore, because the next handler may reuse it.
-typedef struct {
-  void* extra_arg;
+struct grpc_handler_private_op_data {
+  void* extra_arg = nullptr;
   grpc_closure closure;
-} grpc_handler_private_op_data;
+  grpc_handler_private_op_data() { memset(&closure, 0, sizeof(closure)); }
+};
 
 typedef struct grpc_transport_stream_op_batch_payload
     grpc_transport_stream_op_batch_payload;

data/src/core/tsi/alts/handshaker/alts_handshaker_client.cc

@@ -363,7 +363,7 @@ static tsi_result handshaker_client_next(alts_handshaker_client* c,
   alts_grpc_handshaker_client* client =
       reinterpret_cast<alts_grpc_handshaker_client*>(c);
   grpc_slice_unref_internal(client->recv_bytes);
-  client->recv_bytes = grpc_slice_ref(*bytes_received);
+  client->recv_bytes = grpc_slice_ref_internal(*bytes_received);
   grpc_byte_buffer* buffer = get_serialized_next(bytes_received);
   if (buffer == nullptr) {
     gpr_log(GPR_ERROR, "get_serialized_next() failed");
@@ -406,7 +406,7 @@ static const alts_handshaker_client_vtable vtable = {
 alts_handshaker_client* alts_grpc_handshaker_client_create(
     alts_tsi_handshaker* handshaker, grpc_channel* channel,
     const char* handshaker_service_url, grpc_pollset_set* interested_parties,
-    grpc_alts_credentials_options* options, grpc_slice target_name,
+    grpc_alts_credentials_options* options, const grpc_slice& target_name,
     grpc_iomgr_cb_func grpc_cb, tsi_handshaker_on_next_done_cb cb,
     void* user_data, alts_handshaker_client_vtable* vtable_for_testing,
     bool is_client) {
@@ -487,7 +487,7 @@ void alts_handshaker_client_set_recv_bytes_for_testing(
   GPR_ASSERT(c != nullptr);
   alts_grpc_handshaker_client* client =
       reinterpret_cast<alts_grpc_handshaker_client*>(c);
-  client->recv_bytes = grpc_slice_ref(*recv_bytes);
+  client->recv_bytes = grpc_slice_ref_internal(*recv_bytes);
 }
 
 void alts_handshaker_client_set_fields_for_testing(