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 "src/core/lib/surface/init.h"
20
21 #include <address_sorting/address_sorting.h>
22 #include <grpc/fork.h>
23 #include <grpc/grpc.h>
24 #include <grpc/impl/channel_arg_names.h>
25 #include <grpc/support/log.h>
26 #include <grpc/support/port_platform.h>
27 #include <grpc/support/sync.h>
28 #include <grpc/support/time.h>
29
30 #include "absl/base/thread_annotations.h"
31 #include "absl/log/log.h"
32 #include "absl/time/clock.h"
33 #include "absl/time/time.h"
34 #include "src/core/client_channel/backup_poller.h"
35 #include "src/core/config/core_configuration.h"
36 #include "src/core/lib/debug/trace.h"
37 #include "src/core/lib/event_engine/posix_engine/timer_manager.h"
38 #include "src/core/lib/experiments/config.h"
39 #include "src/core/lib/experiments/experiments.h"
40 #include "src/core/lib/iomgr/exec_ctx.h"
41 #include "src/core/lib/iomgr/iomgr.h"
42 #include "src/core/lib/iomgr/timer_manager.h"
43 #include "src/core/lib/security/authorization/grpc_server_authz_filter.h"
44 #include "src/core/lib/security/credentials/credentials.h"
45 #include "src/core/lib/security/security_connector/security_connector.h"
46 #include "src/core/lib/security/transport/auth_filters.h"
47 #include "src/core/lib/surface/channel_stack_type.h"
48 #include "src/core/lib/surface/init_internally.h"
49 #include "src/core/util/fork.h"
50 #include "src/core/util/sync.h"
51 #include "src/core/util/thd.h"
52
53 // Remnants of the old plugin system
54 void grpc_resolver_dns_ares_init(void);
55 void grpc_resolver_dns_ares_shutdown(void);
56 void grpc_resolver_dns_ares_reset_dns_resolver(void);
57
58 extern absl::Status AresInit();
59 extern void AresShutdown();
60
61 #define MAX_PLUGINS 128
62
63 static gpr_once g_basic_init = GPR_ONCE_INIT;
64 static grpc_core::Mutex* g_init_mu;
__anon6f9df3940102() 65 static int g_initializations ABSL_GUARDED_BY(g_init_mu) = []() {
66 grpc_core::CoreConfiguration::SetDefaultBuilder(
67 grpc_core::BuildCoreConfiguration);
68 return 0;
69 }();
70 static grpc_core::CondVar* g_shutting_down_cv;
71 static bool g_shutting_down ABSL_GUARDED_BY(g_init_mu) = false;
72
73 namespace grpc_core {
RegisterSecurityFilters(CoreConfiguration::Builder * builder)74 void RegisterSecurityFilters(CoreConfiguration::Builder* builder) {
75 builder->channel_init()
76 ->RegisterV2Filter<ClientAuthFilter>(GRPC_CLIENT_SUBCHANNEL)
77 .IfHasChannelArg(GRPC_ARG_SECURITY_CONNECTOR);
78 builder->channel_init()
79 ->RegisterV2Filter<ClientAuthFilter>(GRPC_CLIENT_DIRECT_CHANNEL)
80 .IfHasChannelArg(GRPC_ARG_SECURITY_CONNECTOR);
81 builder->channel_init()
82 ->RegisterFilter<ServerAuthFilter>(GRPC_SERVER_CHANNEL)
83 .IfHasChannelArg(GRPC_SERVER_CREDENTIALS_ARG);
84 builder->channel_init()
85 ->RegisterFilter<GrpcServerAuthzFilter>(GRPC_SERVER_CHANNEL)
86 .IfHasChannelArg(GRPC_ARG_AUTHORIZATION_POLICY_PROVIDER)
87 .After<ServerAuthFilter>();
88 }
89 } // namespace grpc_core
90
do_basic_init(void)91 static void do_basic_init(void) {
92 grpc_core::InitInternally = grpc_init;
93 grpc_core::ShutdownInternally = grpc_shutdown;
94 grpc_core::IsInitializedInternally = []() {
95 return grpc_is_initialized() != 0;
96 };
97 gpr_log_verbosity_init();
98 g_init_mu = new grpc_core::Mutex();
99 g_shutting_down_cv = new grpc_core::CondVar();
100 gpr_time_init();
101 grpc_core::PrintExperimentsList();
102 grpc_core::Fork::GlobalInit();
103 grpc_fork_handlers_auto_register();
104 grpc_tracer_init();
105 grpc_client_channel_global_init_backup_polling();
106 }
107
grpc_init(void)108 void grpc_init(void) {
109 gpr_once_init(&g_basic_init, do_basic_init);
110
111 grpc_core::MutexLock lock(g_init_mu);
112 if (++g_initializations == 1) {
113 if (g_shutting_down) {
114 g_shutting_down = false;
115 g_shutting_down_cv->SignalAll();
116 }
117 grpc_iomgr_init();
118 if (grpc_core::IsEventEngineDnsEnabled()) {
119 address_sorting_init();
120 auto status = AresInit();
121 if (!status.ok()) {
122 VLOG(2) << "AresInit failed: " << status.message();
123 } else {
124 // TODO(yijiem): remove this once we remove the iomgr dns system.
125 grpc_resolver_dns_ares_reset_dns_resolver();
126 }
127 } else {
128 grpc_resolver_dns_ares_init();
129 }
130 grpc_iomgr_start();
131 }
132
133 GRPC_TRACE_LOG(api, INFO) << "grpc_init(void)";
134 }
135
grpc_shutdown_internal_locked(void)136 void grpc_shutdown_internal_locked(void)
137 ABSL_EXCLUSIVE_LOCKS_REQUIRED(g_init_mu) {
138 {
139 grpc_core::ExecCtx exec_ctx(0);
140 grpc_iomgr_shutdown_background_closure();
141 grpc_timer_manager_set_threading(false); // shutdown timer_manager thread
142 if (grpc_core::IsEventEngineDnsEnabled()) {
143 address_sorting_shutdown();
144 AresShutdown();
145 } else {
146 grpc_resolver_dns_ares_shutdown();
147 }
148 grpc_iomgr_shutdown();
149 }
150 g_shutting_down = false;
151 g_shutting_down_cv->SignalAll();
152 }
153
grpc_shutdown_from_cleanup_thread(void *)154 void grpc_shutdown_from_cleanup_thread(void* /*ignored*/) {
155 GRPC_TRACE_LOG(api, INFO) << "grpc_shutdown_from_cleanup_thread";
156 grpc_core::MutexLock lock(g_init_mu);
157 // We have released lock from the shutdown thread and it is possible that
158 // another grpc_init has been called, and do nothing if that is the case.
159 if (--g_initializations != 0) {
160 return;
161 }
162 grpc_shutdown_internal_locked();
163 VLOG(2) << "grpc_shutdown from cleanup thread done";
164 }
165
grpc_shutdown(void)166 void grpc_shutdown(void) {
167 GRPC_TRACE_LOG(api, INFO) << "grpc_shutdown(void)";
168 grpc_core::MutexLock lock(g_init_mu);
169
170 if (--g_initializations == 0) {
171 grpc_core::ApplicationCallbackExecCtx* acec =
172 grpc_core::ApplicationCallbackExecCtx::Get();
173 if (!grpc_iomgr_is_any_background_poller_thread() &&
174 !grpc_event_engine::experimental::TimerManager::
175 IsTimerManagerThread() &&
176 (acec == nullptr ||
177 (acec->Flags() & GRPC_APP_CALLBACK_EXEC_CTX_FLAG_IS_INTERNAL_THREAD) ==
178 0) &&
179 grpc_core::ExecCtx::Get() == nullptr) {
180 // just run clean-up when this is called on non-executor thread.
181 VLOG(2) << "grpc_shutdown starts clean-up now";
182 g_shutting_down = true;
183 grpc_shutdown_internal_locked();
184 VLOG(2) << "grpc_shutdown done";
185 } else {
186 // spawn a detached thread to do the actual clean up in case we are
187 // currently in an executor thread.
188 VLOG(2) << "grpc_shutdown spawns clean-up thread";
189 g_initializations++;
190 g_shutting_down = true;
191 grpc_core::Thread cleanup_thread(
192 "grpc_shutdown", grpc_shutdown_from_cleanup_thread, nullptr, nullptr,
193 grpc_core::Thread::Options().set_joinable(false).set_tracked(false));
194 cleanup_thread.Start();
195 }
196 }
197 }
198
grpc_shutdown_blocking(void)199 void grpc_shutdown_blocking(void) {
200 GRPC_TRACE_LOG(api, INFO) << "grpc_shutdown_blocking(void)";
201 grpc_core::MutexLock lock(g_init_mu);
202 if (--g_initializations == 0) {
203 g_shutting_down = true;
204 grpc_shutdown_internal_locked();
205 }
206 }
207
grpc_is_initialized(void)208 int grpc_is_initialized(void) {
209 int r;
210 gpr_once_init(&g_basic_init, do_basic_init);
211 grpc_core::MutexLock lock(g_init_mu);
212 r = g_initializations > 0;
213 return r;
214 }
215
grpc_maybe_wait_for_async_shutdown(void)216 void grpc_maybe_wait_for_async_shutdown(void) {
217 gpr_once_init(&g_basic_init, do_basic_init);
218 grpc_core::MutexLock lock(g_init_mu);
219 while (g_shutting_down) {
220 g_shutting_down_cv->Wait(g_init_mu);
221 }
222 }
223
grpc_wait_for_shutdown_with_timeout(absl::Duration timeout)224 bool grpc_wait_for_shutdown_with_timeout(absl::Duration timeout) {
225 GRPC_TRACE_LOG(api, INFO) << "grpc_wait_for_shutdown_with_timeout()";
226 const auto started = absl::Now();
227 const auto deadline = started + timeout;
228 gpr_once_init(&g_basic_init, do_basic_init);
229 grpc_core::MutexLock lock(g_init_mu);
230 while (g_initializations != 0) {
231 if (g_shutting_down_cv->WaitWithDeadline(g_init_mu, deadline)) {
232 LOG(ERROR) << "grpc_wait_for_shutdown_with_timeout() timed out.";
233 return false;
234 }
235 }
236 GRPC_TRACE_LOG(api, INFO)
237 << "grpc_wait_for_shutdown_with_timeout() took " << absl::Now() - started;
238 return true;
239 }
240