Home | History | Annotate | Download | only in browser 
      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   virtual ~CrashHandlerHostLinux();
     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   virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE;
     53   virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE;
     54 
     55   // MessageLoop::DestructionObserver impl:
     56   virtual 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_
     94