1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
|
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "content/child/child_process.h"
#include <string.h>
#include "base/bind.h"
#include "base/clang_profiling_buildflags.h"
#include "base/lazy_instance.h"
#include "base/message_loop/message_pump_type.h"
#include "base/process/process_handle.h"
#include "base/single_thread_task_runner.h"
#include "base/task/thread_pool/thread_pool_instance.h"
#include "base/threading/thread.h"
#include "base/threading/thread_local.h"
#include "build/build_config.h"
#include "build/config/compiler/compiler_buildflags.h"
#include "content/child/child_thread_impl.h"
#include "content/common/android/cpu_time_metrics.h"
#include "content/common/mojo_core_library_support.h"
#include "content/public/common/content_switches.h"
#include "mojo/public/cpp/system/dynamic_library_support.h"
#include "sandbox/policy/sandbox_type.h"
#include "services/tracing/public/cpp/trace_startup.h"
#include "third_party/blink/public/common/features.h"
#if BUILDFLAG(CLANG_PROFILING_INSIDE_SANDBOX)
#include "base/test/clang_profiling.h"
#endif
#if defined(OS_ANDROID)
#include "content/common/android/cpu_affinity.h"
#endif
namespace content {
namespace {
base::LazyInstance<base::ThreadLocalPointer<ChildProcess>>::DestructorAtExit
g_lazy_child_process_tls = LAZY_INSTANCE_INITIALIZER;
}
ChildProcess::ChildProcess(base::ThreadPriority io_thread_priority,
const std::string& thread_pool_name,
std::unique_ptr<base::ThreadPoolInstance::InitParams>
thread_pool_init_params)
: ref_count_(0),
shutdown_event_(base::WaitableEvent::ResetPolicy::MANUAL,
base::WaitableEvent::InitialState::NOT_SIGNALED),
io_thread_("Chrome_ChildIOThread") {
DCHECK(!g_lazy_child_process_tls.Pointer()->Get());
g_lazy_child_process_tls.Pointer()->Set(this);
#if defined(OS_LINUX) || defined(OS_CHROMEOS)
const base::CommandLine& command_line =
*base::CommandLine::ForCurrentProcess();
const bool is_embedded_in_browser_process =
!command_line.HasSwitch(switches::kProcessType);
if (IsMojoCoreSharedLibraryEnabled() && !is_embedded_in_browser_process) {
// If we're in a child process on Linux and dynamic Mojo Core is in use, we
// expect early process startup code (see ContentMainRunnerImpl::Run()) to
// have already loaded the library via |mojo::LoadCoreLibrary()|, rendering
// this call safe even from within a strict sandbox.
MojoInitializeFlags flags = MOJO_INITIALIZE_FLAG_NONE;
if (sandbox::policy::IsUnsandboxedSandboxType(
sandbox::policy::SandboxTypeFromCommandLine(command_line))) {
flags |= MOJO_INITIALIZE_FLAG_FORCE_DIRECT_SHARED_MEMORY_ALLOCATION;
}
CHECK_EQ(MOJO_RESULT_OK, mojo::InitializeCoreLibrary(flags));
}
#endif
// Initialize ThreadPoolInstance if not already done. A ThreadPoolInstance may
// already exist when ChildProcess is instantiated in the browser process or
// in a test process.
if (!base::ThreadPoolInstance::Get()) {
if (thread_pool_init_params) {
base::ThreadPoolInstance::Create(thread_pool_name);
base::ThreadPoolInstance::Get()->Start(*thread_pool_init_params.get());
} else {
base::ThreadPoolInstance::CreateAndStartWithDefaultParams(
thread_pool_name);
}
DCHECK(base::ThreadPoolInstance::Get());
initialized_thread_pool_ = true;
}
tracing::InitTracingPostThreadPoolStartAndFeatureList();
#if defined(OS_ANDROID)
SetupCpuTimeMetrics();
// For child processes, this requires allowing of the sched_setaffinity()
// syscall in the sandbox (baseline_policy_android.cc). When this call is
// removed, the sandbox allowlist should be updated too.
SetupCpuAffinityPollingOnce();
#endif
// We can't recover from failing to start the IO thread.
base::Thread::Options thread_options(base::MessagePumpType::IO, 0);
thread_options.priority = io_thread_priority;
#if defined(OS_ANDROID)
// TODO(reveman): Remove this in favor of setting it explicitly for each type
// of process.
if (base::FeatureList::IsEnabled(
blink::features::kBlinkCompositorUseDisplayThreadPriority)) {
thread_options.priority = base::ThreadPriority::DISPLAY;
}
#endif
CHECK(io_thread_.StartWithOptions(thread_options));
}
ChildProcess::~ChildProcess() {
DCHECK(g_lazy_child_process_tls.Pointer()->Get() == this);
// Signal this event before destroying the child process. That way all
// background threads can cleanup.
// For example, in the renderer the RenderThread instances will be able to
// notice shutdown before the render process begins waiting for them to exit.
shutdown_event_.Signal();
if (main_thread_) { // null in unittests.
main_thread_->Shutdown();
if (main_thread_->ShouldBeDestroyed()) {
main_thread_.reset();
} else {
// Leak the main_thread_. See a comment in
// RenderThreadImpl::ShouldBeDestroyed.
main_thread_.release();
}
}
g_lazy_child_process_tls.Pointer()->Set(nullptr);
io_thread_.Stop();
if (initialized_thread_pool_) {
DCHECK(base::ThreadPoolInstance::Get());
base::ThreadPoolInstance::Get()->Shutdown();
}
#if BUILDFLAG(CLANG_PROFILING_INSIDE_SANDBOX) && BUILDFLAG(CLANG_PGO)
// Flush the profiling data to disk. Doing this manually (vs relying on this
// being done automatically when the process exits) will ensure that this data
// doesn't get lost if the process is fast killed.
base::WriteClangProfilingProfile();
#endif
}
ChildThreadImpl* ChildProcess::main_thread() {
return main_thread_.get();
}
void ChildProcess::set_main_thread(ChildThreadImpl* thread) {
main_thread_.reset(thread);
}
void ChildProcess::AddRefProcess() {
DCHECK(!main_thread_.get() || // null in unittests.
main_thread_->main_thread_runner()->BelongsToCurrentThread());
ref_count_++;
}
void ChildProcess::ReleaseProcess() {
DCHECK(!main_thread_.get() || // null in unittests.
main_thread_->main_thread_runner()->BelongsToCurrentThread());
DCHECK(ref_count_);
if (--ref_count_)
return;
if (main_thread_) // null in unittests.
main_thread_->OnProcessFinalRelease();
}
ChildProcess* ChildProcess::current() {
return g_lazy_child_process_tls.Pointer()->Get();
}
base::WaitableEvent* ChildProcess::GetShutDownEvent() {
return &shutdown_event_;
}
} // namespace content
|
