components/crash/browser/crash_dump_manager_android.cc

   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 #include "components/crash/browser/crash_dump_manager_android.h"
   6
   7 #include "base/bind.h"
   8 #include "base/files/file_util.h"
   9 #include "base/format_macros.h"
  10 #include "base/logging.h"
  11 #include "base/posix/global_descriptors.h"
  12 #include "base/process/process.h"
  13 #include "base/rand_util.h"
  14 #include "base/stl_util.h"
  15 #include "base/strings/stringprintf.h"
  16 #include "content/public/browser/browser_thread.h"
  17 #include "content/public/browser/child_process_data.h"
  18 #include "content/public/browser/file_descriptor_info.h"
  19 #include "content/public/browser/notification_service.h"
  20 #include "content/public/browser/notification_types.h"
  21 #include "content/public/browser/render_process_host.h"
  22
  23 using content::BrowserThread;
  24
  25 namespace breakpad {
  26
  27 // static
  28 CrashDumpManager* CrashDumpManager::instance_ = NULL;
  29
  30 // static
  31 CrashDumpManager* CrashDumpManager::GetInstance() {
  32   CHECK(instance_);
  33   return instance_;
  34 }
  35
  36 CrashDumpManager::CrashDumpManager(const base::FilePath& crash_dump_dir)
  37     : crash_dump_dir_(crash_dump_dir) {
  38   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
  39   DCHECK(!instance_);
  40
  41   instance_ = this;
  42
  43   notification_registrar_.Add(this,
  44                               content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
  45                               content::NotificationService::AllSources());
  46   notification_registrar_.Add(this,
  47                               content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
  48                               content::NotificationService::AllSources());
  49
  50   BrowserChildProcessObserver::Add(this);
  51 }
  52
  53 CrashDumpManager::~CrashDumpManager() {
  54   instance_ = NULL;
  55
  56   BrowserChildProcessObserver::Remove(this);
  57 }
  58
  59 base::File CrashDumpManager::CreateMinidumpFile(int child_process_id) {
  60   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::PROCESS_LAUNCHER));
  61   base::FilePath minidump_path;
  62   if (!base::CreateTemporaryFile(&minidump_path))
  63     return base::File();
  64
  65   // We need read permission as the minidump is generated in several phases
  66   // and needs to be read at some point.
  67   int flags = base::File::FLAG_OPEN | base::File::FLAG_READ |
  68               base::File::FLAG_WRITE;
  69   base::File minidump_file(minidump_path, flags);
  70   if (!minidump_file.IsValid()) {
  71     LOG(ERROR) << "Failed to create temporary file, crash won't be reported.";
  72     return base::File();
  73   }
  74
  75   {
  76     base::AutoLock auto_lock(child_process_id_to_minidump_path_lock_);
  77     DCHECK(!ContainsKey(child_process_id_to_minidump_path_, child_process_id));
  78     child_process_id_to_minidump_path_[child_process_id] = minidump_path;
  79   }
  80   return minidump_file.Pass();
  81 }
  82
  83 // static
  84 void CrashDumpManager::ProcessMinidump(const base::FilePath& minidump_path,
  85                                        base::ProcessHandle pid) {
  86   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
  87   CHECK(instance_);
  88   int64 file_size = 0;
  89   int r = base::GetFileSize(minidump_path, &file_size);
  90   DCHECK(r) << "Failed to retrieve size for minidump "
  91             << minidump_path.value();
  92
  93   if (file_size == 0) {
  94     // Empty minidump, this process did not crash. Just remove the file.
  95     r = base::DeleteFile(minidump_path, false);
  96     DCHECK(r) << "Failed to delete temporary minidump file "
  97               << minidump_path.value();
  98     return;
  99   }
 100
 101   // We are dealing with a valid minidump. Copy it to the crash report
 102   // directory from where Java code will upload it later on.
 103   if (instance_->crash_dump_dir_.empty()) {
 104     NOTREACHED() << "Failed to retrieve the crash dump directory.";
 105     return;
 106   }
 107   const uint64 rand = base::RandUint64();
 108   const std::string filename =
 109       base::StringPrintf("chromium-renderer-minidump-%016" PRIx64 ".dmp%d",
 110                          rand, pid);
 111   base::FilePath dest_path = instance_->crash_dump_dir_.Append(filename);
 112   r = base::Move(minidump_path, dest_path);
 113   if (!r) {
 114     LOG(ERROR) << "Failed to move crash dump from " << minidump_path.value()
 115                << " to " << dest_path.value();
 116     base::DeleteFile(minidump_path, false);
 117     return;
 118   }
 119   VLOG(1) << "Crash minidump successfully generated: " <<
 120       instance_->crash_dump_dir_.Append(filename).value();
 121 }
 122
 123 void CrashDumpManager::BrowserChildProcessHostDisconnected(
 124     const content::ChildProcessData& data) {
 125   OnChildExit(data.id, data.handle);
 126 }
 127
 128 void CrashDumpManager::BrowserChildProcessCrashed(
 129     const content::ChildProcessData& data) {
 130   OnChildExit(data.id, data.handle);
 131 }
 132
 133 void CrashDumpManager::Observe(int type,
 134                                const content::NotificationSource& source,
 135                                const content::NotificationDetails& details) {
 136   switch (type) {
 137     case content::NOTIFICATION_RENDERER_PROCESS_TERMINATED:
 138       // NOTIFICATION_RENDERER_PROCESS_TERMINATED is sent when the renderer
 139       // process is cleanly shutdown. However, we need to fallthrough so that
 140       // we close the minidump_fd we kept open.
 141     case content::NOTIFICATION_RENDERER_PROCESS_CLOSED: {
 142       content::RenderProcessHost* rph =
 143           content::Source<content::RenderProcessHost>(source).ptr();
 144       OnChildExit(rph->GetID(), rph->GetHandle());
 145       break;
 146     }
 147     default:
 148       NOTREACHED();
 149       return;
 150   }
 151 }
 152
 153 void CrashDumpManager::OnChildExit(int child_process_id,
 154                                    base::ProcessHandle pid) {
 155   base::FilePath minidump_path;
 156   {
 157     base::AutoLock auto_lock(child_process_id_to_minidump_path_lock_);
 158     ChildProcessIDToMinidumpPath::iterator iter =
 159         child_process_id_to_minidump_path_.find(child_process_id);
 160     if (iter == child_process_id_to_minidump_path_.end()) {
 161       // We might get a NOTIFICATION_RENDERER_PROCESS_TERMINATED and a
 162       // NOTIFICATION_RENDERER_PROCESS_CLOSED.
 163       return;
 164     }
 165     minidump_path = iter->second;
 166     child_process_id_to_minidump_path_.erase(iter);
 167   }
 168   BrowserThread::PostTask(
 169       BrowserThread::FILE, FROM_HERE,
 170       base::Bind(&CrashDumpManager::ProcessMinidump, minidump_path, pid));
 171 }
 172
 173 }  // namespace breakpad