src/core/lib/iomgr/iomgr.cc

   1 /*
   2  *
   3  * Copyright 2015 gRPC authors.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  */
  18
  19 #include <grpc/support/port_platform.h>
  20
  21 #include "src/core/lib/iomgr/iomgr.h"
  22
  23 #include <inttypes.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26
  27 #include <grpc/support/alloc.h>
  28 #include <grpc/support/log.h>
  29 #include <grpc/support/string_util.h>
  30 #include <grpc/support/sync.h>
  31
  32 #include "src/core/lib/gpr/env.h"
  33 #include "src/core/lib/gpr/string.h"
  34 #include "src/core/lib/gpr/useful.h"
  35 #include "src/core/lib/gprpp/thd.h"
  36 #include "src/core/lib/iomgr/buffer_list.h"
  37 #include "src/core/lib/iomgr/exec_ctx.h"
  38 #include "src/core/lib/iomgr/executor.h"
  39 #include "src/core/lib/iomgr/internal_errqueue.h"
  40 #include "src/core/lib/iomgr/iomgr_internal.h"
  41 #include "src/core/lib/iomgr/timer.h"
  42 #include "src/core/lib/iomgr/timer_manager.h"
  43
  44 static gpr_mu g_mu;
  45 static gpr_cv g_rcv;
  46 static int g_shutdown;
  47 static grpc_iomgr_object g_root_object;
  48
  49 void grpc_iomgr_init() {
  50   grpc_core::ExecCtx exec_ctx;
  51   grpc_determine_iomgr_platform();
  52   g_shutdown = 0;
  53   gpr_mu_init(&g_mu);
  54   gpr_cv_init(&g_rcv);
  55   grpc_core::Executor::InitAll();
  56   grpc_timer_list_init();
  57   g_root_object.next = g_root_object.prev = &g_root_object;
  58   g_root_object.name = (char*)"root";
  59   grpc_iomgr_platform_init();
  60   grpc_core::grpc_errqueue_init();
  61 }
  62
  63 void grpc_iomgr_start() { grpc_timer_manager_init(); }
  64
  65 static size_t count_objects(void) {
  66   grpc_iomgr_object* obj;
  67   size_t n = 0;
  68   for (obj = g_root_object.next; obj != &g_root_object; obj = obj->next) {
  69     n++;
  70   }
  71   return n;
  72 }
  73
  74 size_t grpc_iomgr_count_objects_for_testing(void) { return count_objects(); }
  75
  76 static void dump_objects(const char* kind) {
  77   grpc_iomgr_object* obj;
  78   for (obj = g_root_object.next; obj != &g_root_object; obj = obj->next) {
  79     gpr_log(GPR_DEBUG, "%s OBJECT: %s %p", kind, obj->name, obj);
  80   }
  81 }
  82
  83 void grpc_iomgr_shutdown() {
  84   gpr_timespec shutdown_deadline = gpr_time_add(
  85       gpr_now(GPR_CLOCK_REALTIME), gpr_time_from_seconds(10, GPR_TIMESPAN));
  86   gpr_timespec last_warning_time = gpr_now(GPR_CLOCK_REALTIME);
  87
  88   {
  89     grpc_timer_manager_shutdown();
  90     grpc_iomgr_platform_flush();
  91     grpc_core::Executor::ShutdownAll();
  92
  93     gpr_mu_lock(&g_mu);
  94     g_shutdown = 1;
  95     while (g_root_object.next != &g_root_object) {
  96       if (gpr_time_cmp(
  97               gpr_time_sub(gpr_now(GPR_CLOCK_REALTIME), last_warning_time),
  98               gpr_time_from_seconds(1, GPR_TIMESPAN)) >= 0) {
  99         if (g_root_object.next != &g_root_object) {
 100           gpr_log(GPR_DEBUG,
 101                   "Waiting for %" PRIuPTR " iomgr objects to be destroyed",
 102                   count_objects());
 103         }
 104         last_warning_time = gpr_now(GPR_CLOCK_REALTIME);
 105       }
 106       grpc_core::ExecCtx::Get()->SetNowIomgrShutdown();
 107       if (grpc_timer_check(nullptr) == GRPC_TIMERS_FIRED) {
 108         gpr_mu_unlock(&g_mu);
 109         grpc_core::ExecCtx::Get()->Flush();
 110         grpc_iomgr_platform_flush();
 111         gpr_mu_lock(&g_mu);
 112         continue;
 113       }
 114       if (g_root_object.next != &g_root_object) {
 115         if (grpc_iomgr_abort_on_leaks()) {
 116           gpr_log(GPR_DEBUG,
 117                   "Failed to free %" PRIuPTR
 118                   " iomgr objects before shutdown deadline: "
 119                   "memory leaks are likely",
 120                   count_objects());
 121           dump_objects("LEAKED");
 122           abort();
 123         }
 124         gpr_timespec short_deadline =
 125             gpr_time_add(gpr_now(GPR_CLOCK_MONOTONIC),
 126                          gpr_time_from_millis(100, GPR_TIMESPAN));
 127         if (gpr_cv_wait(&g_rcv, &g_mu, short_deadline)) {
 128           if (gpr_time_cmp(gpr_now(GPR_CLOCK_REALTIME), shutdown_deadline) >
 129               0) {
 130             if (g_root_object.next != &g_root_object) {
 131               gpr_log(GPR_DEBUG,
 132                       "Failed to free %" PRIuPTR
 133                       " iomgr objects before shutdown deadline: "
 134                       "memory leaks are likely",
 135                       count_objects());
 136               dump_objects("LEAKED");
 137             }
 138             break;
 139           }
 140         }
 141       }
 142     }
 143     gpr_mu_unlock(&g_mu);
 144     grpc_timer_list_shutdown();
 145     grpc_core::ExecCtx::Get()->Flush();
 146   }
 147
 148   /* ensure all threads have left g_mu */
 149   gpr_mu_lock(&g_mu);
 150   gpr_mu_unlock(&g_mu);
 151
 152   grpc_iomgr_platform_shutdown();
 153   gpr_mu_destroy(&g_mu);
 154   gpr_cv_destroy(&g_rcv);
 155 }
 156
 157 void grpc_iomgr_shutdown_background_closure() {
 158   grpc_iomgr_platform_shutdown_background_closure();
 159 }
 160
 161 bool grpc_iomgr_is_any_background_poller_thread() {
 162   return grpc_iomgr_platform_is_any_background_poller_thread();
 163 }
 164
 165 bool grpc_iomgr_add_closure_to_background_poller(grpc_closure* closure,
 166                                                  grpc_error* error) {
 167   return grpc_iomgr_platform_add_closure_to_background_poller(closure, error);
 168 }
 169
 170 void grpc_iomgr_register_object(grpc_iomgr_object* obj, const char* name) {
 171   obj->name = gpr_strdup(name);
 172   gpr_mu_lock(&g_mu);
 173   obj->next = &g_root_object;
 174   obj->prev = g_root_object.prev;
 175   obj->next->prev = obj->prev->next = obj;
 176   gpr_mu_unlock(&g_mu);
 177 }
 178
 179 void grpc_iomgr_unregister_object(grpc_iomgr_object* obj) {
 180   gpr_mu_lock(&g_mu);
 181   obj->next->prev = obj->prev;
 182   obj->prev->next = obj->next;
 183   gpr_cv_signal(&g_rcv);
 184   gpr_mu_unlock(&g_mu);
 185   gpr_free(obj->name);
 186 }
 187
 188 bool grpc_iomgr_abort_on_leaks(void) {
 189   char* env = gpr_getenv("GRPC_ABORT_ON_LEAKS");
 190   bool should_we = gpr_is_true(env);
 191   gpr_free(env);
 192   return should_we;
 193 }