| OLD | NEW |
|---|
| (Empty) |
| 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 "base/bind.h" | |
| 8 #include "base/bind_helpers.h" | |
| 9 #include "base/command_line.h" | |
| 10 #include "base/logging.h" | |
| 11 #include "base/mac/foundation_util.h" | |
| 12 #include "base/mach_ipc_mac.h" | |
| 13 #include "base/string_util.h" | |
| 14 #include "base/stringprintf.h" | |
| 15 #include "base/strings/sys_string_conversions.h" | |
| 16 #include "base/threading/platform_thread.h" | |
| 17 #include "content/browser/renderer_host/render_process_host_impl.h" | |
| 18 #include "content/public/browser/child_process_data.h" | |
| 19 #include "content/public/browser/browser_thread.h" | |
| 20 #include "content/public/browser/notification_service.h" | |
| 21 #include "content/public/browser/notification_types.h" | |
| 22 #include "content/public/common/content_switches.h" | |
| 23 | |
| 24 namespace content { | |
| 25 | |
| 26 namespace { | |
| 27 // Prints a string representation of a Mach error code. | |
| 28 std::string MachErrorCode(kern_return_t err) { | |
| 29 return base::StringPrintf("0x%x %s", err, mach_error_string(err)); | |
| 30 } | |
| 31 } // namespace | |
| 32 | |
| 33 class MachListenerThreadDelegate : public base::PlatformThread::Delegate { | |
| 34 public: | |
| 35 MachListenerThreadDelegate(MachBroker* broker) : broker_(broker) { | |
| 36 DCHECK(broker_); | |
| 37 std::string port_name = MachBroker::GetMachPortName(); | |
| 38 | |
| 39 // Create the receive port in the constructor, not in ThreadMain(). It is | |
| 40 // important to create and register the receive port before starting the | |
| 41 // thread so that child processes will always have someone who's listening. | |
| 42 receive_port_.reset(new base::ReceivePort(port_name.c_str())); | |
| 43 } | |
| 44 | |
| 45 // Implement |PlatformThread::Delegate|. | |
| 46 virtual void ThreadMain() OVERRIDE { | |
| 47 base::MachReceiveMessage message; | |
| 48 kern_return_t err; | |
| 49 while ((err = receive_port_->WaitForMessage(&message, | |
| 50 MACH_MSG_TIMEOUT_NONE)) == | |
| 51 KERN_SUCCESS) { | |
| 52 // 0 was the secret message id. Reject any messages that don't have it. | |
| 53 if (message.GetMessageID() != 0) { | |
| 54 LOG(ERROR) << "Received message with incorrect id: " | |
| 55 << message.GetMessageID(); | |
| 56 continue; | |
| 57 } | |
| 58 | |
| 59 const task_t child_task = message.GetTranslatedPort(0); | |
| 60 if (child_task == MACH_PORT_NULL) { | |
| 61 LOG(ERROR) << "parent GetTranslatedPort(0) failed."; | |
| 62 continue; | |
| 63 } | |
| 64 | |
| 65 // It is possible for the child process to die after the call to | |
| 66 // |pid_for_task()| but before the call to |FinalizePid()|. To prevent | |
| 67 // leaking MachBroker map entries in this case, lock around both these | |
| 68 // calls. If the child dies, the death notification will be processed | |
| 69 // after the call to FinalizePid(), ensuring proper cleanup. | |
| 70 base::AutoLock lock(broker_->GetLock()); | |
| 71 | |
| 72 int pid; | |
| 73 err = pid_for_task(child_task, &pid); | |
| 74 if (err == KERN_SUCCESS) { | |
| 75 broker_->FinalizePid(pid, | |
| 76 MachBroker::MachInfo().SetTask(child_task)); | |
| 77 } else { | |
| 78 LOG(ERROR) << "Error getting pid for task " << child_task | |
| 79 << ": " << MachErrorCode(err); | |
| 80 } | |
| 81 } | |
| 82 | |
| 83 LOG(ERROR) << "Mach listener thread exiting; " | |
| 84 << "parent WaitForMessage() likely failed: " | |
| 85 << MachErrorCode(err); | |
| 86 } | |
| 87 | |
| 88 private: | |
| 89 // The Mach port to listen on. Created on thread startup. | |
| 90 scoped_ptr<base::ReceivePort> receive_port_; | |
| 91 | |
| 92 // The MachBroker to use when new child task rights are received. Can be | |
| 93 // NULL. | |
| 94 MachBroker* broker_; // weak | |
| 95 | |
| 96 DISALLOW_COPY_AND_ASSIGN(MachListenerThreadDelegate); | |
| 97 }; | |
| 98 | |
| 99 // Returns the global MachBroker. | |
| 100 MachBroker* MachBroker::GetInstance() { | |
| 101 return Singleton<MachBroker, LeakySingletonTraits<MachBroker> >::get(); | |
| 102 } | |
| 103 | |
| 104 void MachBroker::EnsureRunning() { | |
| 105 lock_.AssertAcquired(); | |
| 106 | |
| 107 if (!listener_thread_started_) { | |
| 108 listener_thread_started_ = true; | |
| 109 | |
| 110 BrowserThread::PostTask( | |
| 111 BrowserThread::UI, FROM_HERE, | |
| 112 base::Bind(&MachBroker::RegisterNotifications, base::Unretained(this))); | |
| 113 | |
| 114 // Intentional leak. This thread is never joined or reaped. | |
| 115 base::PlatformThread::CreateNonJoinable( | |
| 116 0, new MachListenerThreadDelegate(this)); | |
| 117 } | |
| 118 } | |
| 119 | |
| 120 // Adds a placeholder to the map for the given pid with MACH_PORT_NULL. | |
| 121 void MachBroker::AddPlaceholderForPid(base::ProcessHandle pid) { | |
| 122 lock_.AssertAcquired(); | |
| 123 | |
| 124 MachInfo mach_info; | |
| 125 DCHECK_EQ(0u, mach_map_.count(pid)); | |
| 126 mach_map_[pid] = mach_info; | |
| 127 } | |
| 128 | |
| 129 // Updates the mapping for |pid| to include the given |mach_info|. | |
| 130 void MachBroker::FinalizePid(base::ProcessHandle pid, | |
| 131 const MachInfo& mach_info) { | |
| 132 lock_.AssertAcquired(); | |
| 133 | |
| 134 const int count = mach_map_.count(pid); | |
| 135 if (count == 0) { | |
| 136 // Do nothing for unknown pids. | |
| 137 LOG(ERROR) << "Unknown process " << pid << " is sending Mach IPC messages!"; | |
| 138 return; | |
| 139 } | |
| 140 | |
| 141 DCHECK_EQ(1, count); | |
| 142 DCHECK(mach_map_[pid].mach_task_ == MACH_PORT_NULL); | |
| 143 if (mach_map_[pid].mach_task_ == MACH_PORT_NULL) | |
| 144 mach_map_[pid] = mach_info; | |
| 145 } | |
| 146 | |
| 147 // Removes all mappings belonging to |pid| from the broker. | |
| 148 void MachBroker::InvalidatePid(base::ProcessHandle pid) { | |
| 149 base::AutoLock lock(lock_); | |
| 150 MachBroker::MachMap::iterator it = mach_map_.find(pid); | |
| 151 if (it == mach_map_.end()) | |
| 152 return; | |
| 153 | |
| 154 kern_return_t kr = mach_port_deallocate(mach_task_self(), | |
| 155 it->second.mach_task_); | |
| 156 LOG_IF(WARNING, kr != KERN_SUCCESS) | |
| 157 << "Failed to mach_port_deallocate mach task " << it->second.mach_task_ | |
| 158 << ", error " << MachErrorCode(kr); | |
| 159 mach_map_.erase(it); | |
| 160 } | |
| 161 | |
| 162 base::Lock& MachBroker::GetLock() { | |
| 163 return lock_; | |
| 164 } | |
| 165 | |
| 166 // Returns the mach task belonging to |pid|. | |
| 167 mach_port_t MachBroker::TaskForPid(base::ProcessHandle pid) const { | |
| 168 base::AutoLock lock(lock_); | |
| 169 MachBroker::MachMap::const_iterator it = mach_map_.find(pid); | |
| 170 if (it == mach_map_.end()) | |
| 171 return MACH_PORT_NULL; | |
| 172 return it->second.mach_task_; | |
| 173 } | |
| 174 | |
| 175 void MachBroker::BrowserChildProcessHostDisconnected( | |
| 176 const ChildProcessData& data) { | |
| 177 InvalidatePid(data.handle); | |
| 178 } | |
| 179 | |
| 180 void MachBroker::BrowserChildProcessCrashed(const ChildProcessData& data) { | |
| 181 InvalidatePid(data.handle); | |
| 182 } | |
| 183 | |
| 184 void MachBroker::Observe(int type, | |
| 185 const NotificationSource& source, | |
| 186 const NotificationDetails& details) { | |
| 187 // TODO(rohitrao): These notifications do not always carry the proper PIDs, | |
| 188 // especially when the renderer is already gone or has crashed. Find a better | |
| 189 // way to listen for child process deaths. http://crbug.com/55734 | |
| 190 base::ProcessHandle handle = 0; | |
| 191 switch (type) { | |
| 192 case NOTIFICATION_RENDERER_PROCESS_CLOSED: | |
| 193 handle = Details<RenderProcessHost::RendererClosedDetails>( | |
| 194 details)->handle; | |
| 195 break; | |
| 196 case NOTIFICATION_RENDERER_PROCESS_TERMINATED: | |
| 197 handle = Source<RenderProcessHost>(source)->GetHandle(); | |
| 198 break; | |
| 199 default: | |
| 200 NOTREACHED() << "Unexpected notification"; | |
| 201 break; | |
| 202 } | |
| 203 InvalidatePid(handle); | |
| 204 } | |
| 205 | |
| 206 // static | |
| 207 std::string MachBroker::GetMachPortName() { | |
| 208 const CommandLine* command_line = CommandLine::ForCurrentProcess(); | |
| 209 const bool is_child = command_line->HasSwitch(switches::kProcessType); | |
| 210 | |
| 211 // In non-browser (child) processes, use the parent's pid. | |
| 212 const pid_t pid = is_child ? getppid() : getpid(); | |
| 213 return base::StringPrintf("%s.rohitfork.%d", base::mac::BaseBundleID(), pid); | |
| 214 } | |
| 215 | |
| 216 MachBroker::MachBroker() : listener_thread_started_(false) { | |
| 217 } | |
| 218 | |
| 219 MachBroker::~MachBroker() {} | |
| 220 | |
| 221 void MachBroker::RegisterNotifications() { | |
| 222 registrar_.Add(this, NOTIFICATION_RENDERER_PROCESS_CLOSED, | |
| 223 NotificationService::AllBrowserContextsAndSources()); | |
| 224 registrar_.Add(this, NOTIFICATION_RENDERER_PROCESS_TERMINATED, | |
| 225 NotificationService::AllBrowserContextsAndSources()); | |
| 226 | |
| 227 // No corresponding StopObservingBrowserChildProcesses, | |
| 228 // we leak this singleton. | |
| 229 BrowserChildProcessObserver::Add(this); | |
| 230 } | |
| 231 | |
| 232 } // namespace content | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 13845008:
[Mac] Remove base::LaunchSynchronize and rewrite content::MachBroker. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src