components/crash/browser/crash_handler_host_linux.h

   1 // Copyright 2013 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 #ifndef COMPONENTS_CRASH_BROWSER_CRASH_HANDLER_HOST_LINUX_H_
   6 #define COMPONENTS_CRASH_BROWSER_CRASH_HANDLER_HOST_LINUX_H_
   7
   8 #include <sys/types.h>
   9
  10 #include <string>
  11
  12 #include "base/compiler_specific.h"
  13 #include "base/files/file_path.h"
  14 #include "base/memory/scoped_ptr.h"
  15 #include "base/message_loop/message_loop.h"
  16 #include "base/threading/sequenced_worker_pool.h"
  17
  18 namespace base {
  19 class Thread;
  20 }
  21
  22 namespace breakpad {
  23
  24 struct BreakpadInfo;
  25
  26 // This is the host for processes which run breakpad inside the sandbox on
  27 // Linux or Android. We perform the crash dump from the browser because it
  28 // allows us to be outside the sandbox.
  29 //
  30 // Processes signal that they need to be dumped by sending a datagram over a
  31 // UNIX domain socket. All processes of the same type share the client end of
  32 // this socket which is installed in their descriptor table before exec.
  33 class CrashHandlerHostLinux : public base::MessageLoopForIO::Watcher,
  34                               public base::MessageLoop::DestructionObserver {
  35  public:
  36   CrashHandlerHostLinux(const std::string& process_type,
  37                         const base::FilePath& dumps_path,
  38                         bool upload);
  39   ~CrashHandlerHostLinux() override;
  40
  41   // Starts the uploader thread. Must be called immediately after creating the
  42   // class.
  43   void StartUploaderThread();
  44
  45   // Get the file descriptor which processes should be given in order to signal
  46   // crashes to the browser.
  47   int GetDeathSignalSocket() const {
  48     return process_socket_;
  49   }
  50
  51   // MessagePumbLibevent::Watcher impl:
  52   void OnFileCanWriteWithoutBlocking(int fd) override;
  53   void OnFileCanReadWithoutBlocking(int fd) override;
  54
  55   // MessageLoop::DestructionObserver impl:
  56   void WillDestroyCurrentMessageLoop() override;
  57
  58   // Whether we are shutting down or not.
  59   bool IsShuttingDown() const;
  60
  61  private:
  62   void Init();
  63
  64   // Do work in a sequenced worker pool for OnFileCanReadWithoutBlocking().
  65   void WriteDumpFile(scoped_ptr<BreakpadInfo> info,
  66                      scoped_ptr<char[]> crash_context,
  67                      pid_t crashing_pid,
  68                      int signal_fd);
  69
  70   // Continue OnFileCanReadWithoutBlocking()'s work on the IO thread.
  71   void QueueCrashDumpTask(scoped_ptr<BreakpadInfo> info, int signal_fd);
  72
  73   std::string process_type_;
  74   base::FilePath dumps_path_;
  75   bool upload_;
  76
  77   int process_socket_;
  78   int browser_socket_;
  79
  80   base::MessageLoopForIO::FileDescriptorWatcher file_descriptor_watcher_;
  81   scoped_ptr<base::Thread> uploader_thread_;
  82   bool shutting_down_;
  83
  84   // Unique sequence token so that writing crash dump won't be blocked
  85   // by other tasks.
  86   base::SequencedWorkerPool::SequenceToken worker_pool_token_;
  87
  88   DISALLOW_COPY_AND_ASSIGN(CrashHandlerHostLinux);
  89 };
  90
  91 }  // namespace breakpad
  92
  93 #endif  // COMPONENTS_CRASH_BROWSER_CRASH_HANDLER_HOST_LINUX_H_