| OLD | NEW |
|---|
| (Empty) |
| 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 // On Linux, when the user tries to launch a second copy of chrome, we check | |
| 6 // for a socket in the user's profile directory. If the socket file is open we | |
| 7 // send a message to the first chrome browser process with the current | |
| 8 // directory and second process command line flags. The second process then | |
| 9 // exits. | |
| 10 // | |
| 11 // Because many networked filesystem implementations do not support unix domain | |
| 12 // sockets, we create the socket in a temporary directory and create a symlink | |
| 13 // in the profile. This temporary directory is no longer bound to the profile, | |
| 14 // and may disappear across a reboot or login to a separate session. To bind | |
| 15 // them, we store a unique cookie in the profile directory, which must also be | |
| 16 // present in the remote directory to connect. The cookie is checked both before | |
| 17 // and after the connection. /tmp is sticky, and different Chrome sessions use | |
| 18 // different cookies. Thus, a matching cookie before and after means the | |
| 19 // connection was to a directory with a valid cookie. | |
| 20 // | |
| 21 // We also have a lock file, which is a symlink to a non-existent destination. | |
| 22 // The destination is a string containing the hostname and process id of | |
| 23 // chrome's browser process, eg. "SingletonLock -> example.com-9156". When the | |
| 24 // first copy of chrome exits it will delete the lock file on shutdown, so that | |
| 25 // a different instance on a different host may then use the profile directory. | |
| 26 // | |
| 27 // If writing to the socket fails, the hostname in the lock is checked to see if | |
| 28 // another instance is running a different host using a shared filesystem (nfs, | |
| 29 // etc.) If the hostname differs an error is displayed and the second process | |
| 30 // exits. Otherwise the first process (if any) is killed and the second process | |
| 31 // starts as normal. | |
| 32 // | |
| 33 // When the second process sends the current directory and command line flags to | |
| 34 // the first process, it waits for an ACK message back from the first process | |
| 35 // for a certain time. If there is no ACK message back in time, then the first | |
| 36 // process will be considered as hung for some reason. The second process then | |
| 37 // retrieves the process id from the symbol link and kills it by sending | |
| 38 // SIGKILL. Then the second process starts as normal. | |
| 39 | |
| 40 #include "chrome/browser/process_singleton.h" | |
| 41 | |
| 42 #include <errno.h> | |
| 43 #include <fcntl.h> | |
| 44 #include <signal.h> | |
| 45 #include <sys/socket.h> | |
| 46 #include <sys/stat.h> | |
| 47 #include <sys/types.h> | |
| 48 #include <sys/un.h> | |
| 49 #include <unistd.h> | |
| 50 | |
| 51 #include <cstring> | |
| 52 #include <set> | |
| 53 #include <string> | |
| 54 | |
| 55 #include "base/base_paths.h" | |
| 56 #include "base/basictypes.h" | |
| 57 #include "base/bind.h" | |
| 58 #include "base/command_line.h" | |
| 59 #include "base/file_util.h" | |
| 60 #include "base/files/file_path.h" | |
| 61 #include "base/logging.h" | |
| 62 #include "base/message_loop/message_loop.h" | |
| 63 #include "base/path_service.h" | |
| 64 #include "base/posix/eintr_wrapper.h" | |
| 65 #include "base/rand_util.h" | |
| 66 #include "base/safe_strerror_posix.h" | |
| 67 #include "base/sequenced_task_runner_helpers.h" | |
| 68 #include "base/stl_util.h" | |
| 69 #include "base/strings/string_number_conversions.h" | |
| 70 #include "base/strings/string_split.h" | |
| 71 #include "base/strings/stringprintf.h" | |
| 72 #include "base/strings/sys_string_conversions.h" | |
| 73 #include "base/strings/utf_string_conversions.h" | |
| 74 #include "base/threading/platform_thread.h" | |
| 75 #include "base/time/time.h" | |
| 76 #include "base/timer/timer.h" | |
| 77 #include "chrome/browser/ui/process_singleton_dialog_linux.h" | |
| 78 #include "chrome/common/chrome_constants.h" | |
| 79 #include "content/public/browser/browser_thread.h" | |
| 80 #include "grit/chromium_strings.h" | |
| 81 #include "grit/generated_resources.h" | |
| 82 #include "net/base/net_util.h" | |
| 83 #include "ui/base/l10n/l10n_util.h" | |
| 84 | |
| 85 #if defined(TOOLKIT_VIEWS) && !defined(OS_CHROMEOS) | |
| 86 #include "ui/views/linux_ui/linux_ui.h" | |
| 87 #endif | |
| 88 | |
| 89 using content::BrowserThread; | |
| 90 | |
| 91 const int ProcessSingleton::kTimeoutInSeconds; | |
| 92 | |
| 93 namespace { | |
| 94 | |
| 95 static bool g_disable_prompt; | |
| 96 const char kStartToken[] = "START"; | |
| 97 const char kACKToken[] = "ACK"; | |
| 98 const char kShutdownToken[] = "SHUTDOWN"; | |
| 99 const char kTokenDelimiter = '\0'; | |
| 100 const int kMaxMessageLength = 32 * 1024; | |
| 101 const int kMaxACKMessageLength = arraysize(kShutdownToken) - 1; | |
| 102 | |
| 103 const char kLockDelimiter = '-'; | |
| 104 | |
| 105 // Set a file descriptor to be non-blocking. | |
| 106 // Return 0 on success, -1 on failure. | |
| 107 int SetNonBlocking(int fd) { | |
| 108 int flags = fcntl(fd, F_GETFL, 0); | |
| 109 if (-1 == flags) | |
| 110 return flags; | |
| 111 if (flags & O_NONBLOCK) | |
| 112 return 0; | |
| 113 return fcntl(fd, F_SETFL, flags | O_NONBLOCK); | |
| 114 } | |
| 115 | |
| 116 // Set the close-on-exec bit on a file descriptor. | |
| 117 // Returns 0 on success, -1 on failure. | |
| 118 int SetCloseOnExec(int fd) { | |
| 119 int flags = fcntl(fd, F_GETFD, 0); | |
| 120 if (-1 == flags) | |
| 121 return flags; | |
| 122 if (flags & FD_CLOEXEC) | |
| 123 return 0; | |
| 124 return fcntl(fd, F_SETFD, flags | FD_CLOEXEC); | |
| 125 } | |
| 126 | |
| 127 // Close a socket and check return value. | |
| 128 void CloseSocket(int fd) { | |
| 129 int rv = IGNORE_EINTR(close(fd)); | |
| 130 DCHECK_EQ(0, rv) << "Error closing socket: " << safe_strerror(errno); | |
| 131 } | |
| 132 | |
| 133 // Write a message to a socket fd. | |
| 134 bool WriteToSocket(int fd, const char *message, size_t length) { | |
| 135 DCHECK(message); | |
| 136 DCHECK(length); | |
| 137 size_t bytes_written = 0; | |
| 138 do { | |
| 139 ssize_t rv = HANDLE_EINTR( | |
| 140 write(fd, message + bytes_written, length - bytes_written)); | |
| 141 if (rv < 0) { | |
| 142 if (errno == EAGAIN || errno == EWOULDBLOCK) { | |
| 143 // The socket shouldn't block, we're sending so little data. Just give | |
| 144 // up here, since NotifyOtherProcess() doesn't have an asynchronous api. | |
| 145 LOG(ERROR) << "ProcessSingleton would block on write(), so it gave up."; | |
| 146 return false; | |
| 147 } | |
| 148 PLOG(ERROR) << "write() failed"; | |
| 149 return false; | |
| 150 } | |
| 151 bytes_written += rv; | |
| 152 } while (bytes_written < length); | |
| 153 | |
| 154 return true; | |
| 155 } | |
| 156 | |
| 157 // Wait a socket for read for a certain timeout in seconds. | |
| 158 // Returns -1 if error occurred, 0 if timeout reached, > 0 if the socket is | |
| 159 // ready for read. | |
| 160 int WaitSocketForRead(int fd, int timeout) { | |
| 161 fd_set read_fds; | |
| 162 struct timeval tv; | |
| 163 | |
| 164 FD_ZERO(&read_fds); | |
| 165 FD_SET(fd, &read_fds); | |
| 166 tv.tv_sec = timeout; | |
| 167 tv.tv_usec = 0; | |
| 168 | |
| 169 return HANDLE_EINTR(select(fd + 1, &read_fds, NULL, NULL, &tv)); | |
| 170 } | |
| 171 | |
| 172 // Read a message from a socket fd, with an optional timeout in seconds. | |
| 173 // If |timeout| <= 0 then read immediately. | |
| 174 // Return number of bytes actually read, or -1 on error. | |
| 175 ssize_t ReadFromSocket(int fd, char *buf, size_t bufsize, int timeout) { | |
| 176 if (timeout > 0) { | |
| 177 int rv = WaitSocketForRead(fd, timeout); | |
| 178 if (rv <= 0) | |
| 179 return rv; | |
| 180 } | |
| 181 | |
| 182 size_t bytes_read = 0; | |
| 183 do { | |
| 184 ssize_t rv = HANDLE_EINTR(read(fd, buf + bytes_read, bufsize - bytes_read)); | |
| 185 if (rv < 0) { | |
| 186 if (errno != EAGAIN && errno != EWOULDBLOCK) { | |
| 187 PLOG(ERROR) << "read() failed"; | |
| 188 return rv; | |
| 189 } else { | |
| 190 // It would block, so we just return what has been read. | |
| 191 return bytes_read; | |
| 192 } | |
| 193 } else if (!rv) { | |
| 194 // No more data to read. | |
| 195 return bytes_read; | |
| 196 } else { | |
| 197 bytes_read += rv; | |
| 198 } | |
| 199 } while (bytes_read < bufsize); | |
| 200 | |
| 201 return bytes_read; | |
| 202 } | |
| 203 | |
| 204 // Set up a sockaddr appropriate for messaging. | |
| 205 void SetupSockAddr(const std::string& path, struct sockaddr_un* addr) { | |
| 206 addr->sun_family = AF_UNIX; | |
| 207 CHECK(path.length() < arraysize(addr->sun_path)) | |
| 208 << "Socket path too long: " << path; | |
| 209 base::strlcpy(addr->sun_path, path.c_str(), arraysize(addr->sun_path)); | |
| 210 } | |
| 211 | |
| 212 // Set up a socket appropriate for messaging. | |
| 213 int SetupSocketOnly() { | |
| 214 int sock = socket(PF_UNIX, SOCK_STREAM, 0); | |
| 215 PCHECK(sock >= 0) << "socket() failed"; | |
| 216 | |
| 217 int rv = SetNonBlocking(sock); | |
| 218 DCHECK_EQ(0, rv) << "Failed to make non-blocking socket."; | |
| 219 rv = SetCloseOnExec(sock); | |
| 220 DCHECK_EQ(0, rv) << "Failed to set CLOEXEC on socket."; | |
| 221 | |
| 222 return sock; | |
| 223 } | |
| 224 | |
| 225 // Set up a socket and sockaddr appropriate for messaging. | |
| 226 void SetupSocket(const std::string& path, int* sock, struct sockaddr_un* addr) { | |
| 227 *sock = SetupSocketOnly(); | |
| 228 SetupSockAddr(path, addr); | |
| 229 } | |
| 230 | |
| 231 // Read a symbolic link, return empty string if given path is not a symbol link. | |
| 232 base::FilePath ReadLink(const base::FilePath& path) { | |
| 233 base::FilePath target; | |
| 234 if (!base::ReadSymbolicLink(path, &target)) { | |
| 235 // The only errno that should occur is ENOENT. | |
| 236 if (errno != 0 && errno != ENOENT) | |
| 237 PLOG(ERROR) << "readlink(" << path.value() << ") failed"; | |
| 238 } | |
| 239 return target; | |
| 240 } | |
| 241 | |
| 242 // Unlink a path. Return true on success. | |
| 243 bool UnlinkPath(const base::FilePath& path) { | |
| 244 int rv = unlink(path.value().c_str()); | |
| 245 if (rv < 0 && errno != ENOENT) | |
| 246 PLOG(ERROR) << "Failed to unlink " << path.value(); | |
| 247 | |
| 248 return rv == 0; | |
| 249 } | |
| 250 | |
| 251 // Create a symlink. Returns true on success. | |
| 252 bool SymlinkPath(const base::FilePath& target, const base::FilePath& path) { | |
| 253 if (!base::CreateSymbolicLink(target, path)) { | |
| 254 // Double check the value in case symlink suceeded but we got an incorrect | |
| 255 // failure due to NFS packet loss & retry. | |
| 256 int saved_errno = errno; | |
| 257 if (ReadLink(path) != target) { | |
| 258 // If we failed to create the lock, most likely another instance won the | |
| 259 // startup race. | |
| 260 errno = saved_errno; | |
| 261 PLOG(ERROR) << "Failed to create " << path.value(); | |
| 262 return false; | |
| 263 } | |
| 264 } | |
| 265 return true; | |
| 266 } | |
| 267 | |
| 268 // Extract the hostname and pid from the lock symlink. | |
| 269 // Returns true if the lock existed. | |
| 270 bool ParseLockPath(const base::FilePath& path, | |
| 271 std::string* hostname, | |
| 272 int* pid) { | |
| 273 std::string real_path = ReadLink(path).value(); | |
| 274 if (real_path.empty()) | |
| 275 return false; | |
| 276 | |
| 277 std::string::size_type pos = real_path.rfind(kLockDelimiter); | |
| 278 | |
| 279 // If the path is not a symbolic link, or doesn't contain what we expect, | |
| 280 // bail. | |
| 281 if (pos == std::string::npos) { | |
| 282 *hostname = ""; | |
| 283 *pid = -1; | |
| 284 return true; | |
| 285 } | |
| 286 | |
| 287 *hostname = real_path.substr(0, pos); | |
| 288 | |
| 289 const std::string& pid_str = real_path.substr(pos + 1); | |
| 290 if (!base::StringToInt(pid_str, pid)) | |
| 291 *pid = -1; | |
| 292 | |
| 293 return true; | |
| 294 } | |
| 295 | |
| 296 // Returns true if the user opted to unlock the profile. | |
| 297 bool DisplayProfileInUseError(const base::FilePath& lock_path, | |
| 298 const std::string& hostname, | |
| 299 int pid) { | |
| 300 base::string16 error = l10n_util::GetStringFUTF16( | |
| 301 IDS_PROFILE_IN_USE_LINUX, | |
| 302 base::IntToString16(pid), | |
| 303 base::ASCIIToUTF16(hostname)); | |
| 304 base::string16 relaunch_button_text = l10n_util::GetStringUTF16( | |
| 305 IDS_PROFILE_IN_USE_LINUX_RELAUNCH); | |
| 306 LOG(ERROR) << base::SysWideToNativeMB(base::UTF16ToWide(error)).c_str(); | |
| 307 if (!g_disable_prompt) | |
| 308 return ShowProcessSingletonDialog(error, relaunch_button_text); | |
| 309 return false; | |
| 310 } | |
| 311 | |
| 312 bool IsChromeProcess(pid_t pid) { | |
| 313 base::FilePath other_chrome_path(base::GetProcessExecutablePath(pid)); | |
| 314 return (!other_chrome_path.empty() && | |
| 315 other_chrome_path.BaseName() == | |
| 316 base::FilePath(chrome::kBrowserProcessExecutableName)); | |
| 317 } | |
| 318 | |
| 319 // A helper class to hold onto a socket. | |
| 320 class ScopedSocket { | |
| 321 public: | |
| 322 ScopedSocket() : fd_(-1) { Reset(); } | |
| 323 ~ScopedSocket() { Close(); } | |
| 324 int fd() { return fd_; } | |
| 325 void Reset() { | |
| 326 Close(); | |
| 327 fd_ = SetupSocketOnly(); | |
| 328 } | |
| 329 void Close() { | |
| 330 if (fd_ >= 0) | |
| 331 CloseSocket(fd_); | |
| 332 fd_ = -1; | |
| 333 } | |
| 334 private: | |
| 335 int fd_; | |
| 336 }; | |
| 337 | |
| 338 // Returns a random string for uniquifying profile connections. | |
| 339 std::string GenerateCookie() { | |
| 340 return base::Uint64ToString(base::RandUint64()); | |
| 341 } | |
| 342 | |
| 343 bool CheckCookie(const base::FilePath& path, const base::FilePath& cookie) { | |
| 344 return (cookie == ReadLink(path)); | |
| 345 } | |
| 346 | |
| 347 bool ConnectSocket(ScopedSocket* socket, | |
| 348 const base::FilePath& socket_path, | |
| 349 const base::FilePath& cookie_path) { | |
| 350 base::FilePath socket_target; | |
| 351 if (base::ReadSymbolicLink(socket_path, &socket_target)) { | |
| 352 // It's a symlink. Read the cookie. | |
| 353 base::FilePath cookie = ReadLink(cookie_path); | |
| 354 if (cookie.empty()) | |
| 355 return false; | |
| 356 base::FilePath remote_cookie = socket_target.DirName(). | |
| 357 Append(chrome::kSingletonCookieFilename); | |
| 358 // Verify the cookie before connecting. | |
| 359 if (!CheckCookie(remote_cookie, cookie)) | |
| 360 return false; | |
| 361 // Now we know the directory was (at that point) created by the profile | |
| 362 // owner. Try to connect. | |
| 363 sockaddr_un addr; | |
| 364 SetupSockAddr(socket_path.value(), &addr); | |
| 365 int ret = HANDLE_EINTR(connect(socket->fd(), | |
| 366 reinterpret_cast<sockaddr*>(&addr), | |
| 367 sizeof(addr))); | |
| 368 if (ret != 0) | |
| 369 return false; | |
| 370 // Check the cookie again. We only link in /tmp, which is sticky, so, if the | |
| 371 // directory is still correct, it must have been correct in-between when we | |
| 372 // connected. POSIX, sadly, lacks a connectat(). | |
| 373 if (!CheckCookie(remote_cookie, cookie)) { | |
| 374 socket->Reset(); | |
| 375 return false; | |
| 376 } | |
| 377 // Success! | |
| 378 return true; | |
| 379 } else if (errno == EINVAL) { | |
| 380 // It exists, but is not a symlink (or some other error we detect | |
| 381 // later). Just connect to it directly; this is an older version of Chrome. | |
| 382 sockaddr_un addr; | |
| 383 SetupSockAddr(socket_path.value(), &addr); | |
| 384 int ret = HANDLE_EINTR(connect(socket->fd(), | |
| 385 reinterpret_cast<sockaddr*>(&addr), | |
| 386 sizeof(addr))); | |
| 387 return (ret == 0); | |
| 388 } else { | |
| 389 // File is missing, or other error. | |
| 390 if (errno != ENOENT) | |
| 391 PLOG(ERROR) << "readlink failed"; | |
| 392 return false; | |
| 393 } | |
| 394 } | |
| 395 | |
| 396 } // namespace | |
| 397 | |
| 398 /////////////////////////////////////////////////////////////////////////////// | |
| 399 // ProcessSingleton::LinuxWatcher | |
| 400 // A helper class for a Linux specific implementation of the process singleton. | |
| 401 // This class sets up a listener on the singleton socket and handles parsing | |
| 402 // messages that come in on the singleton socket. | |
| 403 class ProcessSingleton::LinuxWatcher | |
| 404 : public base::MessageLoopForIO::Watcher, | |
| 405 public base::MessageLoop::DestructionObserver, | |
| 406 public base::RefCountedThreadSafe<ProcessSingleton::LinuxWatcher, | |
| 407 BrowserThread::DeleteOnIOThread> { | |
| 408 public: | |
| 409 // A helper class to read message from an established socket. | |
| 410 class SocketReader : public base::MessageLoopForIO::Watcher { | |
| 411 public: | |
| 412 SocketReader(ProcessSingleton::LinuxWatcher* parent, | |
| 413 base::MessageLoop* ui_message_loop, | |
| 414 int fd) | |
| 415 : parent_(parent), | |
| 416 ui_message_loop_(ui_message_loop), | |
| 417 fd_(fd), | |
| 418 bytes_read_(0) { | |
| 419 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
| 420 // Wait for reads. | |
| 421 base::MessageLoopForIO::current()->WatchFileDescriptor( | |
| 422 fd, true, base::MessageLoopForIO::WATCH_READ, &fd_reader_, this); | |
| 423 // If we haven't completed in a reasonable amount of time, give up. | |
| 424 timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(kTimeoutInSeconds), | |
| 425 this, &SocketReader::CleanupAndDeleteSelf); | |
| 426 } | |
| 427 | |
| 428 virtual ~SocketReader() { | |
| 429 CloseSocket(fd_); | |
| 430 } | |
| 431 | |
| 432 // MessageLoopForIO::Watcher impl. | |
| 433 virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE; | |
| 434 virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE { | |
| 435 // SocketReader only watches for accept (read) events. | |
| 436 NOTREACHED(); | |
| 437 } | |
| 438 | |
| 439 // Finish handling the incoming message by optionally sending back an ACK | |
| 440 // message and removing this SocketReader. | |
| 441 void FinishWithACK(const char *message, size_t length); | |
| 442 | |
| 443 private: | |
| 444 void CleanupAndDeleteSelf() { | |
| 445 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
| 446 | |
| 447 parent_->RemoveSocketReader(this); | |
| 448 // We're deleted beyond this point. | |
| 449 } | |
| 450 | |
| 451 base::MessageLoopForIO::FileDescriptorWatcher fd_reader_; | |
| 452 | |
| 453 // The ProcessSingleton::LinuxWatcher that owns us. | |
| 454 ProcessSingleton::LinuxWatcher* const parent_; | |
| 455 | |
| 456 // A reference to the UI message loop. | |
| 457 base::MessageLoop* const ui_message_loop_; | |
| 458 | |
| 459 // The file descriptor we're reading. | |
| 460 const int fd_; | |
| 461 | |
| 462 // Store the message in this buffer. | |
| 463 char buf_[kMaxMessageLength]; | |
| 464 | |
| 465 // Tracks the number of bytes we've read in case we're getting partial | |
| 466 // reads. | |
| 467 size_t bytes_read_; | |
| 468 | |
| 469 base::OneShotTimer<SocketReader> timer_; | |
| 470 | |
| 471 DISALLOW_COPY_AND_ASSIGN(SocketReader); | |
| 472 }; | |
| 473 | |
| 474 // We expect to only be constructed on the UI thread. | |
| 475 explicit LinuxWatcher(ProcessSingleton* parent) | |
| 476 : ui_message_loop_(base::MessageLoop::current()), | |
| 477 parent_(parent) { | |
| 478 } | |
| 479 | |
| 480 // Start listening for connections on the socket. This method should be | |
| 481 // called from the IO thread. | |
| 482 void StartListening(int socket); | |
| 483 | |
| 484 // This method determines if we should use the same process and if we should, | |
| 485 // opens a new browser tab. This runs on the UI thread. | |
| 486 // |reader| is for sending back ACK message. | |
| 487 void HandleMessage(const std::string& current_dir, | |
| 488 const std::vector<std::string>& argv, | |
| 489 SocketReader* reader); | |
| 490 | |
| 491 // MessageLoopForIO::Watcher impl. These run on the IO thread. | |
| 492 virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE; | |
| 493 virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE { | |
| 494 // ProcessSingleton only watches for accept (read) events. | |
| 495 NOTREACHED(); | |
| 496 } | |
| 497 | |
| 498 // MessageLoop::DestructionObserver | |
| 499 virtual void WillDestroyCurrentMessageLoop() OVERRIDE { | |
| 500 fd_watcher_.StopWatchingFileDescriptor(); | |
| 501 } | |
| 502 | |
| 503 private: | |
| 504 friend struct BrowserThread::DeleteOnThread<BrowserThread::IO>; | |
| 505 friend class base::DeleteHelper<ProcessSingleton::LinuxWatcher>; | |
| 506 | |
| 507 virtual ~LinuxWatcher() { | |
| 508 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
| 509 STLDeleteElements(&readers_); | |
| 510 | |
| 511 base::MessageLoopForIO* ml = base::MessageLoopForIO::current(); | |
| 512 ml->RemoveDestructionObserver(this); | |
| 513 } | |
| 514 | |
| 515 // Removes and deletes the SocketReader. | |
| 516 void RemoveSocketReader(SocketReader* reader); | |
| 517 | |
| 518 base::MessageLoopForIO::FileDescriptorWatcher fd_watcher_; | |
| 519 | |
| 520 // A reference to the UI message loop (i.e., the message loop we were | |
| 521 // constructed on). | |
| 522 base::MessageLoop* ui_message_loop_; | |
| 523 | |
| 524 // The ProcessSingleton that owns us. | |
| 525 ProcessSingleton* const parent_; | |
| 526 | |
| 527 std::set<SocketReader*> readers_; | |
| 528 | |
| 529 DISALLOW_COPY_AND_ASSIGN(LinuxWatcher); | |
| 530 }; | |
| 531 | |
| 532 void ProcessSingleton::LinuxWatcher::OnFileCanReadWithoutBlocking(int fd) { | |
| 533 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
| 534 // Accepting incoming client. | |
| 535 sockaddr_un from; | |
| 536 socklen_t from_len = sizeof(from); | |
| 537 int connection_socket = HANDLE_EINTR(accept( | |
| 538 fd, reinterpret_cast<sockaddr*>(&from), &from_len)); | |
| 539 if (-1 == connection_socket) { | |
| 540 PLOG(ERROR) << "accept() failed"; | |
| 541 return; | |
| 542 } | |
| 543 int rv = SetNonBlocking(connection_socket); | |
| 544 DCHECK_EQ(0, rv) << "Failed to make non-blocking socket."; | |
| 545 SocketReader* reader = new SocketReader(this, | |
| 546 ui_message_loop_, | |
| 547 connection_socket); | |
| 548 readers_.insert(reader); | |
| 549 } | |
| 550 | |
| 551 void ProcessSingleton::LinuxWatcher::StartListening(int socket) { | |
| 552 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
| 553 // Watch for client connections on this socket. | |
| 554 base::MessageLoopForIO* ml = base::MessageLoopForIO::current(); | |
| 555 ml->AddDestructionObserver(this); | |
| 556 ml->WatchFileDescriptor(socket, true, base::MessageLoopForIO::WATCH_READ, | |
| 557 &fd_watcher_, this); | |
| 558 } | |
| 559 | |
| 560 void ProcessSingleton::LinuxWatcher::HandleMessage( | |
| 561 const std::string& current_dir, const std::vector<std::string>& argv, | |
| 562 SocketReader* reader) { | |
| 563 DCHECK(ui_message_loop_ == base::MessageLoop::current()); | |
| 564 DCHECK(reader); | |
| 565 | |
| 566 if (parent_->notification_callback_.Run(CommandLine(argv), | |
| 567 base::FilePath(current_dir))) { | |
| 568 // Send back "ACK" message to prevent the client process from starting up. | |
| 569 reader->FinishWithACK(kACKToken, arraysize(kACKToken) - 1); | |
| 570 } else { | |
| 571 LOG(WARNING) << "Not handling interprocess notification as browser" | |
| 572 " is shutting down"; | |
| 573 // Send back "SHUTDOWN" message, so that the client process can start up | |
| 574 // without killing this process. | |
| 575 reader->FinishWithACK(kShutdownToken, arraysize(kShutdownToken) - 1); | |
| 576 return; | |
| 577 } | |
| 578 } | |
| 579 | |
| 580 void ProcessSingleton::LinuxWatcher::RemoveSocketReader(SocketReader* reader) { | |
| 581 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
| 582 DCHECK(reader); | |
| 583 readers_.erase(reader); | |
| 584 delete reader; | |
| 585 } | |
| 586 | |
| 587 /////////////////////////////////////////////////////////////////////////////// | |
| 588 // ProcessSingleton::LinuxWatcher::SocketReader | |
| 589 // | |
| 590 | |
| 591 void ProcessSingleton::LinuxWatcher::SocketReader::OnFileCanReadWithoutBlocking( | |
| 592 int fd) { | |
| 593 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
| 594 DCHECK_EQ(fd, fd_); | |
| 595 while (bytes_read_ < sizeof(buf_)) { | |
| 596 ssize_t rv = HANDLE_EINTR( | |
| 597 read(fd, buf_ + bytes_read_, sizeof(buf_) - bytes_read_)); | |
| 598 if (rv < 0) { | |
| 599 if (errno != EAGAIN && errno != EWOULDBLOCK) { | |
| 600 PLOG(ERROR) << "read() failed"; | |
| 601 CloseSocket(fd); | |
| 602 return; | |
| 603 } else { | |
| 604 // It would block, so we just return and continue to watch for the next | |
| 605 // opportunity to read. | |
| 606 return; | |
| 607 } | |
| 608 } else if (!rv) { | |
| 609 // No more data to read. It's time to process the message. | |
| 610 break; | |
| 611 } else { | |
| 612 bytes_read_ += rv; | |
| 613 } | |
| 614 } | |
| 615 | |
| 616 // Validate the message. The shortest message is kStartToken\0x\0x | |
| 617 const size_t kMinMessageLength = arraysize(kStartToken) + 4; | |
| 618 if (bytes_read_ < kMinMessageLength) { | |
| 619 buf_[bytes_read_] = 0; | |
| 620 LOG(ERROR) << "Invalid socket message (wrong length):" << buf_; | |
| 621 CleanupAndDeleteSelf(); | |
| 622 return; | |
| 623 } | |
| 624 | |
| 625 std::string str(buf_, bytes_read_); | |
| 626 std::vector<std::string> tokens; | |
| 627 base::SplitString(str, kTokenDelimiter, &tokens); | |
| 628 | |
| 629 if (tokens.size() < 3 || tokens[0] != kStartToken) { | |
| 630 LOG(ERROR) << "Wrong message format: " << str; | |
| 631 CleanupAndDeleteSelf(); | |
| 632 return; | |
| 633 } | |
| 634 | |
| 635 // Stop the expiration timer to prevent this SocketReader object from being | |
| 636 // terminated unexpectly. | |
| 637 timer_.Stop(); | |
| 638 | |
| 639 std::string current_dir = tokens[1]; | |
| 640 // Remove the first two tokens. The remaining tokens should be the command | |
| 641 // line argv array. | |
| 642 tokens.erase(tokens.begin()); | |
| 643 tokens.erase(tokens.begin()); | |
| 644 | |
| 645 // Return to the UI thread to handle opening a new browser tab. | |
| 646 ui_message_loop_->PostTask(FROM_HERE, base::Bind( | |
| 647 &ProcessSingleton::LinuxWatcher::HandleMessage, | |
| 648 parent_, | |
| 649 current_dir, | |
| 650 tokens, | |
| 651 this)); | |
| 652 fd_reader_.StopWatchingFileDescriptor(); | |
| 653 | |
| 654 // LinuxWatcher::HandleMessage() is in charge of destroying this SocketReader | |
| 655 // object by invoking SocketReader::FinishWithACK(). | |
| 656 } | |
| 657 | |
| 658 void ProcessSingleton::LinuxWatcher::SocketReader::FinishWithACK( | |
| 659 const char *message, size_t length) { | |
| 660 if (message && length) { | |
| 661 // Not necessary to care about the return value. | |
| 662 WriteToSocket(fd_, message, length); | |
| 663 } | |
| 664 | |
| 665 if (shutdown(fd_, SHUT_WR) < 0) | |
| 666 PLOG(ERROR) << "shutdown() failed"; | |
| 667 | |
| 668 BrowserThread::PostTask( | |
| 669 BrowserThread::IO, | |
| 670 FROM_HERE, | |
| 671 base::Bind(&ProcessSingleton::LinuxWatcher::RemoveSocketReader, | |
| 672 parent_, | |
| 673 this)); | |
| 674 // We will be deleted once the posted RemoveSocketReader task runs. | |
| 675 } | |
| 676 | |
| 677 /////////////////////////////////////////////////////////////////////////////// | |
| 678 // ProcessSingleton | |
| 679 // | |
| 680 ProcessSingleton::ProcessSingleton( | |
| 681 const base::FilePath& user_data_dir, | |
| 682 const NotificationCallback& notification_callback) | |
| 683 : notification_callback_(notification_callback), | |
| 684 current_pid_(base::GetCurrentProcId()), | |
| 685 watcher_(new LinuxWatcher(this)) { | |
| 686 socket_path_ = user_data_dir.Append(chrome::kSingletonSocketFilename); | |
| 687 lock_path_ = user_data_dir.Append(chrome::kSingletonLockFilename); | |
| 688 cookie_path_ = user_data_dir.Append(chrome::kSingletonCookieFilename); | |
| 689 | |
| 690 kill_callback_ = base::Bind(&ProcessSingleton::KillProcess, | |
| 691 base::Unretained(this)); | |
| 692 } | |
| 693 | |
| 694 ProcessSingleton::~ProcessSingleton() { | |
| 695 } | |
| 696 | |
| 697 ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcess() { | |
| 698 return NotifyOtherProcessWithTimeout(*CommandLine::ForCurrentProcess(), | |
| 699 kTimeoutInSeconds, | |
| 700 true); | |
| 701 } | |
| 702 | |
| 703 ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcessWithTimeout( | |
| 704 const CommandLine& cmd_line, | |
| 705 int timeout_seconds, | |
| 706 bool kill_unresponsive) { | |
| 707 DCHECK_GE(timeout_seconds, 0); | |
| 708 | |
| 709 ScopedSocket socket; | |
| 710 for (int retries = 0; retries <= timeout_seconds; ++retries) { | |
| 711 // Try to connect to the socket. | |
| 712 if (ConnectSocket(&socket, socket_path_, cookie_path_)) | |
| 713 break; | |
| 714 | |
| 715 // If we're in a race with another process, they may be in Create() and have | |
| 716 // created the lock but not attached to the socket. So we check if the | |
| 717 // process with the pid from the lockfile is currently running and is a | |
| 718 // chrome browser. If so, we loop and try again for |timeout_seconds|. | |
| 719 | |
| 720 std::string hostname; | |
| 721 int pid; | |
| 722 if (!ParseLockPath(lock_path_, &hostname, &pid)) { | |
| 723 // No lockfile exists. | |
| 724 return PROCESS_NONE; | |
| 725 } | |
| 726 | |
| 727 if (hostname.empty()) { | |
| 728 // Invalid lockfile. | |
| 729 UnlinkPath(lock_path_); | |
| 730 return PROCESS_NONE; | |
| 731 } | |
| 732 | |
| 733 if (hostname != net::GetHostName() && !IsChromeProcess(pid)) { | |
| 734 // Locked by process on another host. If the user selected to unlock | |
| 735 // the profile, try to continue; otherwise quit. | |
| 736 if (DisplayProfileInUseError(lock_path_, hostname, pid)) { | |
| 737 UnlinkPath(lock_path_); | |
| 738 return PROCESS_NONE; | |
| 739 } | |
| 740 return PROFILE_IN_USE; | |
| 741 } | |
| 742 | |
| 743 if (!IsChromeProcess(pid)) { | |
| 744 // Orphaned lockfile (no process with pid, or non-chrome process.) | |
| 745 UnlinkPath(lock_path_); | |
| 746 return PROCESS_NONE; | |
| 747 } | |
| 748 | |
| 749 if (IsSameChromeInstance(pid)) { | |
| 750 // Orphaned lockfile (pid is part of same chrome instance we are, even | |
| 751 // though we haven't tried to create a lockfile yet). | |
| 752 UnlinkPath(lock_path_); | |
| 753 return PROCESS_NONE; | |
| 754 } | |
| 755 | |
| 756 if (retries == timeout_seconds) { | |
| 757 // Retries failed. Kill the unresponsive chrome process and continue. | |
| 758 if (!kill_unresponsive || !KillProcessByLockPath()) | |
| 759 return PROFILE_IN_USE; | |
| 760 return PROCESS_NONE; | |
| 761 } | |
| 762 | |
| 763 base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(1)); | |
| 764 } | |
| 765 | |
| 766 timeval timeout = {timeout_seconds, 0}; | |
| 767 setsockopt(socket.fd(), SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout)); | |
| 768 | |
| 769 // Found another process, prepare our command line | |
| 770 // format is "START\0<current dir>\0<argv[0]>\0...\0<argv[n]>". | |
| 771 std::string to_send(kStartToken); | |
| 772 to_send.push_back(kTokenDelimiter); | |
| 773 | |
| 774 base::FilePath current_dir; | |
| 775 if (!PathService::Get(base::DIR_CURRENT, ¤t_dir)) | |
| 776 return PROCESS_NONE; | |
| 777 to_send.append(current_dir.value()); | |
| 778 | |
| 779 const std::vector<std::string>& argv = cmd_line.argv(); | |
| 780 for (std::vector<std::string>::const_iterator it = argv.begin(); | |
| 781 it != argv.end(); ++it) { | |
| 782 to_send.push_back(kTokenDelimiter); | |
| 783 to_send.append(*it); | |
| 784 } | |
| 785 | |
| 786 // Send the message | |
| 787 if (!WriteToSocket(socket.fd(), to_send.data(), to_send.length())) { | |
| 788 // Try to kill the other process, because it might have been dead. | |
| 789 if (!kill_unresponsive || !KillProcessByLockPath()) | |
| 790 return PROFILE_IN_USE; | |
| 791 return PROCESS_NONE; | |
| 792 } | |
| 793 | |
| 794 if (shutdown(socket.fd(), SHUT_WR) < 0) | |
| 795 PLOG(ERROR) << "shutdown() failed"; | |
| 796 | |
| 797 // Read ACK message from the other process. It might be blocked for a certain | |
| 798 // timeout, to make sure the other process has enough time to return ACK. | |
| 799 char buf[kMaxACKMessageLength + 1]; | |
| 800 ssize_t len = | |
| 801 ReadFromSocket(socket.fd(), buf, kMaxACKMessageLength, timeout_seconds); | |
| 802 | |
| 803 // Failed to read ACK, the other process might have been frozen. | |
| 804 if (len <= 0) { | |
| 805 if (!kill_unresponsive || !KillProcessByLockPath()) | |
| 806 return PROFILE_IN_USE; | |
| 807 return PROCESS_NONE; | |
| 808 } | |
| 809 | |
| 810 buf[len] = '\0'; | |
| 811 if (strncmp(buf, kShutdownToken, arraysize(kShutdownToken) - 1) == 0) { | |
| 812 // The other process is shutting down, it's safe to start a new process. | |
| 813 return PROCESS_NONE; | |
| 814 } else if (strncmp(buf, kACKToken, arraysize(kACKToken) - 1) == 0) { | |
| 815 #if defined(TOOLKIT_VIEWS) && !defined(OS_CHROMEOS) | |
| 816 // Likely NULL in unit tests. | |
| 817 views::LinuxUI* linux_ui = views::LinuxUI::instance(); | |
| 818 if (linux_ui) | |
| 819 linux_ui->NotifyWindowManagerStartupComplete(); | |
| 820 #endif | |
| 821 | |
| 822 // Assume the other process is handling the request. | |
| 823 return PROCESS_NOTIFIED; | |
| 824 } | |
| 825 | |
| 826 NOTREACHED() << "The other process returned unknown message: " << buf; | |
| 827 return PROCESS_NOTIFIED; | |
| 828 } | |
| 829 | |
| 830 ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcessOrCreate() { | |
| 831 return NotifyOtherProcessWithTimeoutOrCreate( | |
| 832 *CommandLine::ForCurrentProcess(), | |
| 833 kTimeoutInSeconds); | |
| 834 } | |
| 835 | |
| 836 ProcessSingleton::NotifyResult | |
| 837 ProcessSingleton::NotifyOtherProcessWithTimeoutOrCreate( | |
| 838 const CommandLine& command_line, | |
| 839 int timeout_seconds) { | |
| 840 NotifyResult result = NotifyOtherProcessWithTimeout(command_line, | |
| 841 timeout_seconds, true); | |
| 842 if (result != PROCESS_NONE) | |
| 843 return result; | |
| 844 if (Create()) | |
| 845 return PROCESS_NONE; | |
| 846 // If the Create() failed, try again to notify. (It could be that another | |
| 847 // instance was starting at the same time and managed to grab the lock before | |
| 848 // we did.) | |
| 849 // This time, we don't want to kill anything if we aren't successful, since we | |
| 850 // aren't going to try to take over the lock ourselves. | |
| 851 result = NotifyOtherProcessWithTimeout(command_line, timeout_seconds, false); | |
| 852 if (result != PROCESS_NONE) | |
| 853 return result; | |
| 854 | |
| 855 return LOCK_ERROR; | |
| 856 } | |
| 857 | |
| 858 void ProcessSingleton::OverrideCurrentPidForTesting(base::ProcessId pid) { | |
| 859 current_pid_ = pid; | |
| 860 } | |
| 861 | |
| 862 void ProcessSingleton::OverrideKillCallbackForTesting( | |
| 863 const base::Callback<void(int)>& callback) { | |
| 864 kill_callback_ = callback; | |
| 865 } | |
| 866 | |
| 867 void ProcessSingleton::DisablePromptForTesting() { | |
| 868 g_disable_prompt = true; | |
| 869 } | |
| 870 | |
| 871 bool ProcessSingleton::Create() { | |
| 872 int sock; | |
| 873 sockaddr_un addr; | |
| 874 | |
| 875 // The symlink lock is pointed to the hostname and process id, so other | |
| 876 // processes can find it out. | |
| 877 base::FilePath symlink_content(base::StringPrintf( | |
| 878 "%s%c%u", | |
| 879 net::GetHostName().c_str(), | |
| 880 kLockDelimiter, | |
| 881 current_pid_)); | |
| 882 | |
| 883 // Create symbol link before binding the socket, to ensure only one instance | |
| 884 // can have the socket open. | |
| 885 if (!SymlinkPath(symlink_content, lock_path_)) { | |
| 886 // If we failed to create the lock, most likely another instance won the | |
| 887 // startup race. | |
| 888 return false; | |
| 889 } | |
| 890 | |
| 891 // Create the socket file somewhere in /tmp which is usually mounted as a | |
| 892 // normal filesystem. Some network filesystems (notably AFS) are screwy and | |
| 893 // do not support Unix domain sockets. | |
| 894 if (!socket_dir_.CreateUniqueTempDir()) { | |
| 895 LOG(ERROR) << "Failed to create socket directory."; | |
| 896 return false; | |
| 897 } | |
| 898 // Setup the socket symlink and the two cookies. | |
| 899 base::FilePath socket_target_path = | |
| 900 socket_dir_.path().Append(chrome::kSingletonSocketFilename); | |
| 901 base::FilePath cookie(GenerateCookie()); | |
| 902 base::FilePath remote_cookie_path = | |
| 903 socket_dir_.path().Append(chrome::kSingletonCookieFilename); | |
| 904 UnlinkPath(socket_path_); | |
| 905 UnlinkPath(cookie_path_); | |
| 906 if (!SymlinkPath(socket_target_path, socket_path_) || | |
| 907 !SymlinkPath(cookie, cookie_path_) || | |
| 908 !SymlinkPath(cookie, remote_cookie_path)) { | |
| 909 // We've already locked things, so we can't have lost the startup race, | |
| 910 // but something doesn't like us. | |
| 911 LOG(ERROR) << "Failed to create symlinks."; | |
| 912 if (!socket_dir_.Delete()) | |
| 913 LOG(ERROR) << "Encountered a problem when deleting socket directory."; | |
| 914 return false; | |
| 915 } | |
| 916 | |
| 917 SetupSocket(socket_target_path.value(), &sock, &addr); | |
| 918 | |
| 919 if (bind(sock, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) < 0) { | |
| 920 PLOG(ERROR) << "Failed to bind() " << socket_target_path.value(); | |
| 921 CloseSocket(sock); | |
| 922 return false; | |
| 923 } | |
| 924 | |
| 925 if (listen(sock, 5) < 0) | |
| 926 NOTREACHED() << "listen failed: " << safe_strerror(errno); | |
| 927 | |
| 928 DCHECK(BrowserThread::IsMessageLoopValid(BrowserThread::IO)); | |
| 929 BrowserThread::PostTask( | |
| 930 BrowserThread::IO, | |
| 931 FROM_HERE, | |
| 932 base::Bind(&ProcessSingleton::LinuxWatcher::StartListening, | |
| 933 watcher_.get(), | |
| 934 sock)); | |
| 935 | |
| 936 return true; | |
| 937 } | |
| 938 | |
| 939 void ProcessSingleton::Cleanup() { | |
| 940 UnlinkPath(socket_path_); | |
| 941 UnlinkPath(cookie_path_); | |
| 942 UnlinkPath(lock_path_); | |
| 943 } | |
| 944 | |
| 945 bool ProcessSingleton::IsSameChromeInstance(pid_t pid) { | |
| 946 pid_t cur_pid = current_pid_; | |
| 947 while (pid != cur_pid) { | |
| 948 pid = base::GetParentProcessId(pid); | |
| 949 if (pid < 0) | |
| 950 return false; | |
| 951 if (!IsChromeProcess(pid)) | |
| 952 return false; | |
| 953 } | |
| 954 return true; | |
| 955 } | |
| 956 | |
| 957 bool ProcessSingleton::KillProcessByLockPath() { | |
| 958 std::string hostname; | |
| 959 int pid; | |
| 960 ParseLockPath(lock_path_, &hostname, &pid); | |
| 961 | |
| 962 if (!hostname.empty() && hostname != net::GetHostName()) { | |
| 963 return DisplayProfileInUseError(lock_path_, hostname, pid); | |
| 964 } | |
| 965 UnlinkPath(lock_path_); | |
| 966 | |
| 967 if (IsSameChromeInstance(pid)) | |
| 968 return true; | |
| 969 | |
| 970 if (pid > 0) { | |
| 971 kill_callback_.Run(pid); | |
| 972 return true; | |
| 973 } | |
| 974 | |
| 975 LOG(ERROR) << "Failed to extract pid from path: " << lock_path_.value(); | |
| 976 return true; | |
| 977 } | |
| 978 | |
| 979 void ProcessSingleton::KillProcess(int pid) { | |
| 980 // TODO(james.su@gmail.com): Is SIGKILL ok? | |
| 981 int rv = kill(static_cast<base::ProcessHandle>(pid), SIGKILL); | |
| 982 // ESRCH = No Such Process (can happen if the other process is already in | |
| 983 // progress of shutting down and finishes before we try to kill it). | |
| 984 DCHECK(rv == 0 || errno == ESRCH) << "Error killing process: " | |
| 985 << safe_strerror(errno); | |
| 986 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 218883008:
Use process_singleton_linux on Mac. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src