Home | History | Annotate | Download | only in common 
      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.
     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
     88 ChildProcessHost* ChildProcessHost::Create(ChildProcessHostDelegate* delegate) {
     89   return new ChildProcessHostImpl(delegate);
     90 }
     91 
     92 // static
     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 
    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 
    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 
    154 void ChildProcessHostImpl::AddFilter(IPC::MessageFilter* filter) {
    155   filters_.push_back(filter);
    156 
    157   if (channel_)
    158     filter->OnFilterAdded(channel_.get());
    159 }
    160 
    161 void ChildProcessHostImpl::ForceShutdown() {
    162   Send(new ChildProcessMsg_Shutdown());
    163 }
    164 
    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 
    185 bool ChildProcessHostImpl::IsChannelOpening() {
    186   return opening_channel_;
    187 }
    188 
    189 #if defined(OS_POSIX)
    190 int ChildProcessHostImpl::TakeClientFileDescriptor() {
    191   return channel_->TakeClientFileDescriptor();
    192 }
    193 #endif
    194 
    195 bool ChildProcessHostImpl::Send(IPC::Message* message) {
    196   if (!channel_) {
    197     delete message;
    198     return false;
    199   }
    200   return channel_->Send(message);
    201 }
    202 
    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 
    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 
    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 
    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 
    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 
    295 void ChildProcessHostImpl::OnBadMessageReceived(const IPC::Message& message) {
    296   delegate_->OnBadMessageReceived(message);
    297 }
    298 
    299 void ChildProcessHostImpl::OnAllocateSharedMemory(
    300     uint32 buffer_size,
    301     base::SharedMemoryHandle* handle) {
    302   AllocateSharedMemory(buffer_size, peer_handle_, handle);
    303 }
    304 
    305 void ChildProcessHostImpl::OnShutdownRequest() {
    306   if (delegate_->CanShutdown())
    307     Send(new ChildProcessMsg_Shutdown());
    308 }
    309 
    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