content/browser/mach_broker_mac.mm

   1 // Copyright (c) 2011 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/browser/mach_broker_mac.h"
   6
   7 #include <bsm/libbsm.h>
   8 #include <servers/bootstrap.h>
   9
  10 #include "base/bind.h"
  11 #include "base/bind_helpers.h"
  12 #include "base/command_line.h"
  13 #include "base/logging.h"
  14 #include "base/mac/foundation_util.h"
  15 #include "base/mac/scoped_mach_port.h"
  16 #include "base/strings/string_util.h"
  17 #include "base/strings/stringprintf.h"
  18 #include "base/strings/sys_string_conversions.h"
  19 #include "base/threading/platform_thread.h"
  20 #include "content/browser/renderer_host/render_process_host_impl.h"
  21 #include "content/public/browser/browser_thread.h"
  22 #include "content/public/browser/child_process_data.h"
  23 #include "content/public/browser/notification_service.h"
  24 #include "content/public/browser/notification_types.h"
  25 #include "content/public/common/content_switches.h"
  26
  27 namespace content {
  28
  29 namespace {
  30
  31 // Prints a string representation of a Mach error code.
  32 std::string MachErrorCode(kern_return_t err) {
  33   return base::StringPrintf("0x%x %s", err, mach_error_string(err));
  34 }
  35
  36 // Mach message structure used in the child as a sending message.
  37 struct MachBroker_ChildSendMsg {
  38   mach_msg_header_t header;
  39   mach_msg_body_t body;
  40   mach_msg_port_descriptor_t child_task_port;
  41 };
  42
  43 // Complement to the ChildSendMsg, this is used in the parent for receiving
  44 // a message. Contains a message trailer with audit information.
  45 struct MachBroker_ParentRecvMsg : public MachBroker_ChildSendMsg {
  46   mach_msg_audit_trailer_t trailer;
  47 };
  48
  49 }  // namespace
  50
  51 class MachListenerThreadDelegate : public base::PlatformThread::Delegate {
  52  public:
  53   explicit MachListenerThreadDelegate(MachBroker* broker)
  54       : broker_(broker),
  55         server_port_(MACH_PORT_NULL) {
  56     DCHECK(broker_);
  57   }
  58
  59   bool Init() {
  60     DCHECK(server_port_ == MACH_PORT_NULL);
  61
  62     mach_port_t port;
  63     kern_return_t kr = mach_port_allocate(mach_task_self(),
  64                                           MACH_PORT_RIGHT_RECEIVE,
  65                                           &port);
  66     if (kr != KERN_SUCCESS) {
  67       LOG(ERROR) << "Failed to allocate MachBroker server port: "
  68                  << MachErrorCode(kr);
  69       return false;
  70     }
  71
  72     // Allocate a send right for the server port.
  73     kr = mach_port_insert_right(
  74         mach_task_self(), port, port, MACH_MSG_TYPE_MAKE_SEND);
  75     if (kr != KERN_SUCCESS) {
  76       LOG(ERROR) << "Failed to insert send right for MachBroker server port: "
  77                  << MachErrorCode(kr);
  78       return false;
  79     }
  80
  81     server_port_.reset(port);
  82
  83     // Register the port with the bootstrap server. Because bootstrap_register
  84     // is deprecated, this has to be wraped in an ObjC interface.
  85     NSPort* ns_port = [NSMachPort portWithMachPort:port
  86                                            options:NSMachPortDeallocateNone];
  87     NSString* name = base::SysUTF8ToNSString(broker_->GetMachPortName());
  88     return [[NSMachBootstrapServer sharedInstance] registerPort:ns_port
  89                                                            name:name];
  90   }
  91
  92   // Implement |PlatformThread::Delegate|.
  93   virtual void ThreadMain() OVERRIDE {
  94     MachBroker_ParentRecvMsg msg;
  95     bzero(&msg, sizeof(msg));
  96     msg.header.msgh_size = sizeof(msg);
  97     msg.header.msgh_local_port = server_port_.get();
  98
  99     kern_return_t kr;
 100     do {
 101       // Use the kernel audit information to make sure this message is from
 102       // a task that this process spawned. The kernel audit token contains the
 103       // unspoofable pid of the task that sent the message.
 104       mach_msg_option_t options = MACH_RCV_MSG |
 105           MACH_RCV_TRAILER_TYPE(MACH_RCV_TRAILER_AUDIT) |
 106           MACH_RCV_TRAILER_ELEMENTS(MACH_RCV_TRAILER_AUDIT);
 107
 108       kr = mach_msg(&msg.header, options, 0, sizeof(msg), server_port_,
 109           MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
 110       if (kr == KERN_SUCCESS) {
 111         // TODO(rsesek): In the 10.7 SDK, there's audit_token_to_pid().
 112         pid_t child_pid;
 113         audit_token_to_au32(msg.trailer.msgh_audit,
 114             NULL, NULL, NULL, NULL, NULL, &child_pid, NULL, NULL);
 115
 116         mach_port_t child_task_port = msg.child_task_port.name;
 117
 118         // Take the lock and update the broker information.
 119         base::AutoLock lock(broker_->GetLock());
 120         broker_->FinalizePid(child_pid, child_task_port);
 121       }
 122     } while (kr == KERN_SUCCESS);
 123
 124     LOG(ERROR) << "MachBroker thread exiting; mach_msg() likely failed: "
 125                << MachErrorCode(kr);
 126   }
 127
 128  private:
 129   // The MachBroker to use when new child task rights are received.  Can be
 130   // NULL.
 131   MachBroker* broker_;  // weak
 132
 133   base::mac::ScopedMachPort server_port_;
 134
 135   DISALLOW_COPY_AND_ASSIGN(MachListenerThreadDelegate);
 136 };
 137
 138 bool MachBroker::ChildSendTaskPortToParent() {
 139   // Look up the named MachBroker port that's been registered with the
 140   // bootstrap server.
 141   mach_port_t bootstrap_port;
 142   kern_return_t kr = task_get_bootstrap_port(mach_task_self(), &bootstrap_port);
 143   if (kr != KERN_SUCCESS) {
 144     LOG(ERROR) << "Failed to look up bootstrap port: " << MachErrorCode(kr);
 145     return false;
 146   }
 147
 148   mach_port_t parent_port;
 149   kr = bootstrap_look_up(bootstrap_port,
 150       const_cast<char*>(GetMachPortName().c_str()), &parent_port);
 151   if (kr != KERN_SUCCESS) {
 152     LOG(ERROR) << "Failed to look up named parent port: " << MachErrorCode(kr);
 153     return false;
 154   }
 155
 156   // Create the check in message. This will copy a send right on this process'
 157   // (the child's) task port and send it to the parent.
 158   MachBroker_ChildSendMsg msg;
 159   bzero(&msg, sizeof(msg));
 160   msg.header.msgh_bits = MACH_MSGH_BITS_REMOTE(MACH_MSG_TYPE_COPY_SEND) |
 161                          MACH_MSGH_BITS_COMPLEX;
 162   msg.header.msgh_remote_port = parent_port;
 163   msg.header.msgh_size = sizeof(msg);
 164   msg.body.msgh_descriptor_count = 1;
 165   msg.child_task_port.name = mach_task_self();
 166   msg.child_task_port.disposition = MACH_MSG_TYPE_PORT_SEND;
 167   msg.child_task_port.type = MACH_MSG_PORT_DESCRIPTOR;
 168
 169   kr = mach_msg(&msg.header, MACH_SEND_MSG | MACH_SEND_TIMEOUT, sizeof(msg),
 170       0, MACH_PORT_NULL, 100 /*milliseconds*/, MACH_PORT_NULL);
 171   if (kr != KERN_SUCCESS) {
 172     LOG(ERROR) << "Failed to send task port to parent: " << MachErrorCode(kr);
 173     return false;
 174   }
 175
 176   return true;
 177 }
 178
 179 MachBroker* MachBroker::GetInstance() {
 180   return Singleton<MachBroker, LeakySingletonTraits<MachBroker> >::get();
 181 }
 182
 183 base::Lock& MachBroker::GetLock() {
 184   return lock_;
 185 }
 186
 187 void MachBroker::EnsureRunning() {
 188   lock_.AssertAcquired();
 189
 190   if (!listener_thread_started_) {
 191     listener_thread_started_ = true;
 192
 193     BrowserThread::PostTask(
 194         BrowserThread::UI, FROM_HERE,
 195         base::Bind(&MachBroker::RegisterNotifications, base::Unretained(this)));
 196
 197     // Intentional leak.  This thread is never joined or reaped.
 198     MachListenerThreadDelegate* thread = new MachListenerThreadDelegate(this);
 199     if (thread->Init()) {
 200       base::PlatformThread::CreateNonJoinable(0, thread);
 201     } else {
 202       LOG(ERROR) << "Failed to initialize the MachListenerThreadDelegate";
 203     }
 204   }
 205 }
 206
 207 void MachBroker::AddPlaceholderForPid(base::ProcessHandle pid) {
 208   lock_.AssertAcquired();
 209
 210   DCHECK_EQ(0u, mach_map_.count(pid));
 211   mach_map_[pid] = MACH_PORT_NULL;
 212 }
 213
 214 mach_port_t MachBroker::TaskForPid(base::ProcessHandle pid) const {
 215   base::AutoLock lock(lock_);
 216   MachBroker::MachMap::const_iterator it = mach_map_.find(pid);
 217   if (it == mach_map_.end())
 218     return MACH_PORT_NULL;
 219   return it->second;
 220 }
 221
 222 void MachBroker::BrowserChildProcessHostDisconnected(
 223     const ChildProcessData& data) {
 224   InvalidatePid(data.handle);
 225 }
 226
 227 void MachBroker::BrowserChildProcessCrashed(const ChildProcessData& data) {
 228   InvalidatePid(data.handle);
 229 }
 230
 231 void MachBroker::Observe(int type,
 232                          const NotificationSource& source,
 233                          const NotificationDetails& details) {
 234   // TODO(rohitrao): These notifications do not always carry the proper PIDs,
 235   // especially when the renderer is already gone or has crashed.  Find a better
 236   // way to listen for child process deaths.  http://crbug.com/55734
 237   base::ProcessHandle handle = 0;
 238   switch (type) {
 239     case NOTIFICATION_RENDERER_PROCESS_CLOSED:
 240       handle = Details<RenderProcessHost::RendererClosedDetails>(
 241           details)->handle;
 242       break;
 243     case NOTIFICATION_RENDERER_PROCESS_TERMINATED:
 244       handle = Source<RenderProcessHost>(source)->GetHandle();
 245       break;
 246     default:
 247       NOTREACHED() << "Unexpected notification";
 248       break;
 249   }
 250   InvalidatePid(handle);
 251 }
 252
 253 MachBroker::MachBroker() : listener_thread_started_(false) {
 254 }
 255
 256 MachBroker::~MachBroker() {}
 257
 258 void MachBroker::FinalizePid(base::ProcessHandle pid,
 259                              mach_port_t task_port) {
 260   lock_.AssertAcquired();
 261
 262   MachMap::iterator it = mach_map_.find(pid);
 263   if (it == mach_map_.end()) {
 264     // Do nothing for unknown pids.
 265     LOG(ERROR) << "Unknown process " << pid << " is sending Mach IPC messages!";
 266     return;
 267   }
 268
 269   DCHECK(it->second == MACH_PORT_NULL);
 270   if (it->second == MACH_PORT_NULL)
 271     it->second = task_port;
 272 }
 273
 274 void MachBroker::InvalidatePid(base::ProcessHandle pid) {
 275   base::AutoLock lock(lock_);
 276   MachBroker::MachMap::iterator it = mach_map_.find(pid);
 277   if (it == mach_map_.end())
 278     return;
 279
 280   kern_return_t kr = mach_port_deallocate(mach_task_self(),
 281                                           it->second);
 282   LOG_IF(WARNING, kr != KERN_SUCCESS)
 283      << "Failed to mach_port_deallocate mach task " << it->second
 284      << ", error " << MachErrorCode(kr);
 285   mach_map_.erase(it);
 286 }
 287
 288 // static
 289 std::string MachBroker::GetMachPortName() {
 290   const CommandLine* command_line = CommandLine::ForCurrentProcess();
 291   const bool is_child = command_line->HasSwitch(switches::kProcessType);
 292
 293   // In non-browser (child) processes, use the parent's pid.
 294   const pid_t pid = is_child ? getppid() : getpid();
 295   return base::StringPrintf("%s.rohitfork.%d", base::mac::BaseBundleID(), pid);
 296 }
 297
 298 void MachBroker::RegisterNotifications() {
 299   registrar_.Add(this, NOTIFICATION_RENDERER_PROCESS_CLOSED,
 300                  NotificationService::AllBrowserContextsAndSources());
 301   registrar_.Add(this, NOTIFICATION_RENDERER_PROCESS_TERMINATED,
 302                  NotificationService::AllBrowserContextsAndSources());
 303
 304   // No corresponding StopObservingBrowserChildProcesses,
 305   // we leak this singleton.
 306   BrowserChildProcessObserver::Add(this);
 307 }
 308
 309 }  // namespace content