content/common/child_process_host_impl.cc

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