• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #include "content/common/child_process_host_impl.h"
6 
7 #include <limits>
8 
9 #include "base/atomic_sequence_num.h"
10 #include "base/command_line.h"
11 #include "base/files/file_path.h"
12 #include "base/logging.h"
13 #include "base/metrics/histogram.h"
14 #include "base/path_service.h"
15 #include "base/process/process_metrics.h"
16 #include "base/rand_util.h"
17 #include "base/strings/stringprintf.h"
18 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
19 #include "content/common/child_process_messages.h"
20 #include "content/common/gpu/client/gpu_memory_buffer_impl.h"
21 #include "content/public/common/child_process_host_delegate.h"
22 #include "content/public/common/content_paths.h"
23 #include "content/public/common/content_switches.h"
24 #include "ipc/ipc_channel.h"
25 #include "ipc/ipc_logging.h"
26 #include "ipc/message_filter.h"
27 
28 #if defined(OS_LINUX)
29 #include "base/linux_util.h"
30 #elif defined(OS_WIN)
31 #include "content/common/font_cache_dispatcher_win.h"
32 #endif  // OS_LINUX
33 
34 namespace {
35 
36 #if defined(OS_MACOSX)
37 // Given |path| identifying a Mac-style child process executable path, adjusts
38 // it to correspond to |feature|. For a child process path such as
39 // ".../Chromium Helper.app/Contents/MacOS/Chromium Helper", the transformed
40 // path for feature "NP" would be
41 // ".../Chromium Helper NP.app/Contents/MacOS/Chromium Helper NP". The new
42 // path is returned.
TransformPathForFeature(const base::FilePath & path,const std::string & feature)43 base::FilePath TransformPathForFeature(const base::FilePath& path,
44                                  const std::string& feature) {
45   std::string basename = path.BaseName().value();
46 
47   base::FilePath macos_path = path.DirName();
48   const char kMacOSName[] = "MacOS";
49   DCHECK_EQ(kMacOSName, macos_path.BaseName().value());
50 
51   base::FilePath contents_path = macos_path.DirName();
52   const char kContentsName[] = "Contents";
53   DCHECK_EQ(kContentsName, contents_path.BaseName().value());
54 
55   base::FilePath helper_app_path = contents_path.DirName();
56   const char kAppExtension[] = ".app";
57   std::string basename_app = basename;
58   basename_app.append(kAppExtension);
59   DCHECK_EQ(basename_app, helper_app_path.BaseName().value());
60 
61   base::FilePath root_path = helper_app_path.DirName();
62 
63   std::string new_basename = basename;
64   new_basename.append(1, ' ');
65   new_basename.append(feature);
66   std::string new_basename_app = new_basename;
67   new_basename_app.append(kAppExtension);
68 
69   base::FilePath new_path = root_path.Append(new_basename_app)
70                                      .Append(kContentsName)
71                                      .Append(kMacOSName)
72                                      .Append(new_basename);
73 
74   return new_path;
75 }
76 #endif  // OS_MACOSX
77 
78 // Global atomic to generate child process unique IDs.
79 base::StaticAtomicSequenceNumber g_unique_id;
80 
81 }  // namespace
82 
83 namespace content {
84 
85 int ChildProcessHost::kInvalidUniqueID = -1;
86 
87 // static
Create(ChildProcessHostDelegate * delegate)88 ChildProcessHost* ChildProcessHost::Create(ChildProcessHostDelegate* delegate) {
89   return new ChildProcessHostImpl(delegate);
90 }
91 
92 // static
GetChildPath(int flags)93 base::FilePath ChildProcessHost::GetChildPath(int flags) {
94   base::FilePath child_path;
95 
96   child_path = base::CommandLine::ForCurrentProcess()->GetSwitchValuePath(
97       switches::kBrowserSubprocessPath);
98 
99 #if defined(OS_LINUX)
100   // Use /proc/self/exe rather than our known binary path so updates
101   // can't swap out the binary from underneath us.
102   // When running under Valgrind, forking /proc/self/exe ends up forking the
103   // Valgrind executable, which then crashes. However, it's almost safe to
104   // assume that the updates won't happen while testing with Valgrind tools.
105   if (child_path.empty() && flags & CHILD_ALLOW_SELF && !RunningOnValgrind())
106     child_path = base::FilePath(base::kProcSelfExe);
107 #endif
108 
109   // On most platforms, the child executable is the same as the current
110   // executable.
111   if (child_path.empty())
112     PathService::Get(CHILD_PROCESS_EXE, &child_path);
113 
114 #if defined(OS_MACOSX)
115   DCHECK(!(flags & CHILD_NO_PIE && flags & CHILD_ALLOW_HEAP_EXECUTION));
116 
117   // If needed, choose an executable with special flags set that inform the
118   // kernel to enable or disable specific optional process-wide features.
119   if (flags & CHILD_NO_PIE) {
120     // "NP" is "No PIE". This results in Chromium Helper NP.app or
121     // Google Chrome Helper NP.app.
122     child_path = TransformPathForFeature(child_path, "NP");
123   } else if (flags & CHILD_ALLOW_HEAP_EXECUTION) {
124     // "EH" is "Executable Heap". A non-executable heap is only available to
125     // 32-bit processes on Mac OS X 10.7. Most code can and should run with a
126     // non-executable heap, but the "EH" feature is provided to allow code
127     // intolerant of a non-executable heap to work properly on 10.7. This
128     // results in Chromium Helper EH.app or Google Chrome Helper EH.app.
129     child_path = TransformPathForFeature(child_path, "EH");
130   }
131 #endif
132 
133   return child_path;
134 }
135 
ChildProcessHostImpl(ChildProcessHostDelegate * delegate)136 ChildProcessHostImpl::ChildProcessHostImpl(ChildProcessHostDelegate* delegate)
137     : delegate_(delegate),
138       peer_handle_(base::kNullProcessHandle),
139       opening_channel_(false) {
140 #if defined(OS_WIN)
141   AddFilter(new FontCacheDispatcher());
142 #endif
143 }
144 
~ChildProcessHostImpl()145 ChildProcessHostImpl::~ChildProcessHostImpl() {
146   for (size_t i = 0; i < filters_.size(); ++i) {
147     filters_[i]->OnChannelClosing();
148     filters_[i]->OnFilterRemoved();
149   }
150 
151   base::CloseProcessHandle(peer_handle_);
152 }
153 
AddFilter(IPC::MessageFilter * filter)154 void ChildProcessHostImpl::AddFilter(IPC::MessageFilter* filter) {
155   filters_.push_back(filter);
156 
157   if (channel_)
158     filter->OnFilterAdded(channel_.get());
159 }
160 
ForceShutdown()161 void ChildProcessHostImpl::ForceShutdown() {
162   Send(new ChildProcessMsg_Shutdown());
163 }
164 
CreateChannel()165 std::string ChildProcessHostImpl::CreateChannel() {
166   channel_id_ = IPC::Channel::GenerateVerifiedChannelID(std::string());
167   channel_ = IPC::Channel::CreateServer(channel_id_, this);
168   if (!channel_->Connect())
169     return std::string();
170 
171   for (size_t i = 0; i < filters_.size(); ++i)
172     filters_[i]->OnFilterAdded(channel_.get());
173 
174   // Make sure these messages get sent first.
175 #if defined(IPC_MESSAGE_LOG_ENABLED)
176   bool enabled = IPC::Logging::GetInstance()->Enabled();
177   Send(new ChildProcessMsg_SetIPCLoggingEnabled(enabled));
178 #endif
179 
180   opening_channel_ = true;
181 
182   return channel_id_;
183 }
184 
IsChannelOpening()185 bool ChildProcessHostImpl::IsChannelOpening() {
186   return opening_channel_;
187 }
188 
189 #if defined(OS_POSIX)
TakeClientFileDescriptor()190 int ChildProcessHostImpl::TakeClientFileDescriptor() {
191   return channel_->TakeClientFileDescriptor();
192 }
193 #endif
194 
Send(IPC::Message * message)195 bool ChildProcessHostImpl::Send(IPC::Message* message) {
196   if (!channel_) {
197     delete message;
198     return false;
199   }
200   return channel_->Send(message);
201 }
202 
AllocateSharedMemory(size_t buffer_size,base::ProcessHandle child_process_handle,base::SharedMemoryHandle * shared_memory_handle)203 void ChildProcessHostImpl::AllocateSharedMemory(
204       size_t buffer_size, base::ProcessHandle child_process_handle,
205       base::SharedMemoryHandle* shared_memory_handle) {
206   base::SharedMemory shared_buf;
207   if (!shared_buf.CreateAnonymous(buffer_size)) {
208     *shared_memory_handle = base::SharedMemory::NULLHandle();
209     NOTREACHED() << "Cannot create shared memory buffer";
210     return;
211   }
212   shared_buf.GiveToProcess(child_process_handle, shared_memory_handle);
213 }
214 
GenerateChildProcessUniqueId()215 int ChildProcessHostImpl::GenerateChildProcessUniqueId() {
216   // This function must be threadsafe.
217   //
218   // Historically, this function returned ids started with 1, so in several
219   // places in the code a value of 0 (rather than kInvalidUniqueID) was used as
220   // an invalid value. So we retain those semantics.
221   int id = g_unique_id.GetNext() + 1;
222 
223   CHECK_NE(0, id);
224   CHECK_NE(kInvalidUniqueID, id);
225 
226   return id;
227 }
228 
OnMessageReceived(const IPC::Message & msg)229 bool ChildProcessHostImpl::OnMessageReceived(const IPC::Message& msg) {
230 #ifdef IPC_MESSAGE_LOG_ENABLED
231   IPC::Logging* logger = IPC::Logging::GetInstance();
232   if (msg.type() == IPC_LOGGING_ID) {
233     logger->OnReceivedLoggingMessage(msg);
234     return true;
235   }
236 
237   if (logger->Enabled())
238     logger->OnPreDispatchMessage(msg);
239 #endif
240 
241   bool handled = false;
242   for (size_t i = 0; i < filters_.size(); ++i) {
243     if (filters_[i]->OnMessageReceived(msg)) {
244       handled = true;
245       break;
246     }
247   }
248 
249   if (!handled) {
250     handled = true;
251     IPC_BEGIN_MESSAGE_MAP(ChildProcessHostImpl, msg)
252       IPC_MESSAGE_HANDLER(ChildProcessHostMsg_ShutdownRequest,
253                           OnShutdownRequest)
254       IPC_MESSAGE_HANDLER(ChildProcessHostMsg_SyncAllocateSharedMemory,
255                           OnAllocateSharedMemory)
256       IPC_MESSAGE_HANDLER(ChildProcessHostMsg_SyncAllocateGpuMemoryBuffer,
257                           OnAllocateGpuMemoryBuffer)
258       IPC_MESSAGE_UNHANDLED(handled = false)
259     IPC_END_MESSAGE_MAP()
260 
261     if (!handled)
262       handled = delegate_->OnMessageReceived(msg);
263   }
264 
265 #ifdef IPC_MESSAGE_LOG_ENABLED
266   if (logger->Enabled())
267     logger->OnPostDispatchMessage(msg, channel_id_);
268 #endif
269   return handled;
270 }
271 
OnChannelConnected(int32 peer_pid)272 void ChildProcessHostImpl::OnChannelConnected(int32 peer_pid) {
273   if (!peer_handle_ &&
274       !base::OpenPrivilegedProcessHandle(peer_pid, &peer_handle_)) {
275     peer_handle_ = delegate_->GetHandle();
276     DCHECK(peer_handle_);
277   }
278   opening_channel_ = false;
279   delegate_->OnChannelConnected(peer_pid);
280   for (size_t i = 0; i < filters_.size(); ++i)
281     filters_[i]->OnChannelConnected(peer_pid);
282 }
283 
OnChannelError()284 void ChildProcessHostImpl::OnChannelError() {
285   opening_channel_ = false;
286   delegate_->OnChannelError();
287 
288   for (size_t i = 0; i < filters_.size(); ++i)
289     filters_[i]->OnChannelError();
290 
291   // This will delete host_, which will also destroy this!
292   delegate_->OnChildDisconnected();
293 }
294 
OnBadMessageReceived(const IPC::Message & message)295 void ChildProcessHostImpl::OnBadMessageReceived(const IPC::Message& message) {
296   delegate_->OnBadMessageReceived(message);
297 }
298 
OnAllocateSharedMemory(uint32 buffer_size,base::SharedMemoryHandle * handle)299 void ChildProcessHostImpl::OnAllocateSharedMemory(
300     uint32 buffer_size,
301     base::SharedMemoryHandle* handle) {
302   AllocateSharedMemory(buffer_size, peer_handle_, handle);
303 }
304 
OnShutdownRequest()305 void ChildProcessHostImpl::OnShutdownRequest() {
306   if (delegate_->CanShutdown())
307     Send(new ChildProcessMsg_Shutdown());
308 }
309 
OnAllocateGpuMemoryBuffer(uint32 width,uint32 height,uint32 internalformat,uint32 usage,gfx::GpuMemoryBufferHandle * handle)310 void ChildProcessHostImpl::OnAllocateGpuMemoryBuffer(
311     uint32 width,
312     uint32 height,
313     uint32 internalformat,
314     uint32 usage,
315     gfx::GpuMemoryBufferHandle* handle) {
316   handle->type = gfx::SHARED_MEMORY_BUFFER;
317   AllocateSharedMemory(
318       width * height * GpuMemoryBufferImpl::BytesPerPixel(internalformat),
319       peer_handle_,
320       &handle->handle);
321 }
322 
323 }  // namespace content
324