| // Copyright 2018 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "components/crash/content/app/minidump_with_crashpad_info.h" |
| |
| #include "base/files/file_util.h" |
| #include "third_party/crashpad/crashpad/client/crash_report_database.h" |
| #include "third_party/crashpad/crashpad/client/crashpad_info.h" |
| #include "third_party/crashpad/crashpad/client/settings.h" |
| #include "third_party/crashpad/crashpad/minidump/minidump_extensions.h" |
| |
| namespace crash_reporter { |
| |
| namespace { |
| |
| using FilePosition = uint32_t; |
| const FilePosition kInvalidFilePos = static_cast<FilePosition>(-1); |
| |
| // This class is a helper to edit minidump files written by MiniDumpWriteDump. |
| // It assumes the minidump file it operates on has a directory entry pointing to |
| // a CrashpadInfo entry, which it updates to point to the SimpleDictionary data |
| // it appends to the file contents. |
| class MinidumpUpdater { |
| public: |
| MinidumpUpdater(); |
| |
| // Reads the existing directory from |file|. |
| bool Initialize(base::File* file); |
| |
| // Appends the simple dictionary with |crash_keys| to the file, and updates |
| // the CrashpadInfo with its location. |
| bool AppendSimpleDictionary(const StringStringMap& crash_keys); |
| |
| private: |
| // Writes |data_len| bytes from |data| to the file at the current location. |
| bool WriteData(const void* data, size_t data_len); |
| bool WriteAndAdvance(const void* data, |
| size_t data_len, |
| FilePosition* position); |
| |
| base::File* file_; |
| std::vector<MINIDUMP_DIRECTORY> directory_; |
| |
| DISALLOW_COPY_AND_ASSIGN(MinidumpUpdater); |
| }; |
| |
| MinidumpUpdater::MinidumpUpdater() : file_(nullptr) {} |
| |
| bool MinidumpUpdater::Initialize(base::File* file) { |
| DCHECK(file && file->IsValid()); |
| DCHECK(!file_); |
| |
| // Read the file header. |
| MINIDUMP_HEADER header = {}; |
| int bytes_read = |
| file->Read(0, reinterpret_cast<char*>(&header), sizeof(header)); |
| if (bytes_read != sizeof(header)) |
| return false; |
| if (header.Signature != MINIDUMP_SIGNATURE || header.NumberOfStreams == 0) |
| return false; |
| |
| // Read the stream directory. |
| directory_.resize(header.NumberOfStreams); |
| int bytes_to_read = header.NumberOfStreams * sizeof(directory_[0]); |
| bytes_read = |
| file->Read(header.StreamDirectoryRva, |
| reinterpret_cast<char*>(&directory_[0]), bytes_to_read); |
| if (bytes_read != bytes_to_read) |
| return false; |
| |
| // Crashpad has some fairly unreasonable checking on the minidump header and |
| // directory. Match with those checks for now to allow Crashpad to read the |
| // CrashpadInfo and upload these dumps. |
| |
| // Start by removing any unused directory entries. |
| // TODO(siggi): Fix Crashpad to ignore unused streams. |
| directory_.erase(std::remove_if(directory_.begin(), directory_.end(), |
| [](const MINIDUMP_DIRECTORY& entry) { |
| return entry.StreamType == UnusedStream; |
| }), |
| directory_.end()); |
| |
| // Update the header. |
| // TODO(siggi): Fix Crashpad's version checking. |
| header.Version = MINIDUMP_VERSION; |
| header.NumberOfStreams = base::saturated_cast<ULONG32>(directory_.size()); |
| |
| // Write back the potentially shortened and packed dictionary. |
| int bytes_to_write = header.NumberOfStreams * sizeof(directory_[0]); |
| int bytes_written = file->Write(header.StreamDirectoryRva, |
| reinterpret_cast<const char*>(&directory_[0]), |
| bytes_to_write); |
| if (bytes_written != bytes_to_write) |
| return false; |
| |
| // Write back the header. |
| bytes_written = |
| file->Write(0, reinterpret_cast<const char*>(&header), sizeof(header)); |
| if (bytes_written != sizeof(header)) |
| return false; |
| |
| // Success, stash the file. |
| file_ = file; |
| |
| return true; |
| } |
| |
| bool MinidumpUpdater::AppendSimpleDictionary( |
| const StringStringMap& crash_keys) { |
| DCHECK(file_); |
| |
| // Start by finding the Crashpad directory entry and reading the CrashpadInfo. |
| FilePosition crashpad_info_pos = 0; |
| crashpad::MinidumpCrashpadInfo crashpad_info; |
| for (const auto& entry : directory_) { |
| if (entry.StreamType == crashpad::kMinidumpStreamTypeCrashpadInfo) { |
| // This file is freshly written, so it must contain the same version |
| // CrashpadInfo structure this code compiled against. |
| if (entry.Location.DataSize != sizeof(crashpad_info)) |
| return false; |
| |
| crashpad_info_pos = entry.Location.Rva; |
| break; |
| } |
| } |
| |
| // No CrashpadInfo directory entry found. |
| if (crashpad_info_pos == 0) |
| return false; |
| |
| int bytes_read = |
| file_->Read(crashpad_info_pos, reinterpret_cast<char*>(&crashpad_info), |
| sizeof(crashpad_info)); |
| if (bytes_read != sizeof(crashpad_info)) |
| return false; |
| |
| if (crashpad_info.version != crashpad::MinidumpCrashpadInfo::kVersion) |
| return false; |
| |
| // Seek to the tail of the file, where we're going to extend it. |
| FilePosition next_available_byte = file_->Seek(base::File::FROM_END, 0); |
| if (next_available_byte == kInvalidFilePos) |
| return false; |
| |
| // Write the key/value pairs and collect their locations. |
| std::vector<crashpad::MinidumpSimpleStringDictionaryEntry> entries; |
| for (const auto& kv : crash_keys) { |
| // The key of a key/value pair should never be empty. |
| DCHECK(!kv.first.empty()); |
| |
| crashpad::MinidumpSimpleStringDictionaryEntry entry = {0}; |
| |
| // Skip this key/value if the value is empty. |
| if (!kv.second.empty()) { |
| entry.key = next_available_byte; |
| uint32_t key_len = base::saturated_cast<uint32_t>(kv.first.size()); |
| if (!WriteAndAdvance(&key_len, sizeof(key_len), &next_available_byte) || |
| !WriteAndAdvance(&kv.first[0], key_len, &next_available_byte)) { |
| return false; |
| } |
| |
| entry.value = next_available_byte; |
| uint32_t value_len = base::saturated_cast<uint32_t>(kv.second.size()); |
| if (!WriteAndAdvance(&value_len, sizeof(value_len), |
| &next_available_byte) || |
| !WriteAndAdvance(&kv.second[0], value_len, &next_available_byte)) { |
| return false; |
| } |
| |
| entries.push_back(entry); |
| } |
| } |
| |
| // Write the dictionary array itself - note the array is count-prefixed. |
| FilePosition dict_pos = next_available_byte; |
| uint32_t entry_count = base::saturated_cast<uint32_t>(entries.size()); |
| if (!WriteAndAdvance(&entry_count, sizeof(entry_count), |
| &next_available_byte) || |
| !WriteAndAdvance(&entries[0], entry_count * sizeof(entries[0]), |
| &next_available_byte)) { |
| return false; |
| } |
| |
| // Touch up the CrashpadInfo and write it back to the file. |
| crashpad_info.simple_annotations.DataSize = next_available_byte - dict_pos; |
| crashpad_info.simple_annotations.Rva = dict_pos; |
| |
| int bytes_written = file_->Write( |
| crashpad_info_pos, reinterpret_cast<const char*>(&crashpad_info), |
| sizeof(crashpad_info)); |
| if (bytes_written != sizeof(crashpad_info)) |
| return false; |
| |
| return true; |
| } |
| |
| bool MinidumpUpdater::WriteData(const void* data, size_t data_len) { |
| DCHECK(file_); |
| DCHECK(data); |
| DCHECK_NE(0U, data_len); |
| |
| if (data_len > INT_MAX) |
| return false; |
| |
| int bytes_to_write = static_cast<int>(data_len); |
| int written_bytes = file_->WriteAtCurrentPos( |
| reinterpret_cast<const char*>(data), bytes_to_write); |
| if (written_bytes == -1) |
| return false; |
| |
| return true; |
| } |
| |
| bool MinidumpUpdater::WriteAndAdvance(const void* data, |
| size_t data_len, |
| FilePosition* position) { |
| DCHECK(position); |
| DCHECK_EQ(file_->Seek(base::File::FROM_CURRENT, 0), *position); |
| |
| if (!WriteData(data, data_len)) |
| return false; |
| |
| *position += base::saturated_cast<FilePosition>(data_len); |
| return true; |
| } |
| |
| // Writes a minidump file for |process| to |dump_file| with embedded |
| // CrashpadInfo, containing |crash_keys|, |client_id| and |report_id|. |
| // The |dump_file| must be open for read as well as write. |
| bool MiniDumpWriteDumpWithCrashpadInfo(const base::Process& process, |
| uint32_t minidump_type, |
| MINIDUMP_EXCEPTION_INFORMATION* exc_info, |
| const StringStringMap& crash_keys, |
| const crashpad::UUID& client_id, |
| const crashpad::UUID& report_id, |
| base::File* dump_file) { |
| DCHECK(process.IsValid()); |
| DCHECK(dump_file && dump_file->IsValid()); |
| |
| // The CrashpadInfo structure and its associated directory entry are injected |
| // into the minidump, to minimize the work to patching up the dump. |
| crashpad::MinidumpCrashpadInfo crashpad_info; |
| crashpad_info.version = crashpad::MinidumpCrashpadInfo::kVersion; |
| crashpad_info.client_id = client_id; |
| crashpad_info.report_id = report_id; |
| |
| MINIDUMP_USER_STREAM crashpad_info_stream = { |
| crashpad::kMinidumpStreamTypeCrashpadInfo, // Type |
| sizeof(crashpad_info), // BufferSize |
| &crashpad_info // Buffer |
| }; |
| MINIDUMP_USER_STREAM_INFORMATION user_stream_info = { |
| 1, // UserStreamCount |
| &crashpad_info_stream // UserStreamArray |
| }; |
| |
| // Write the minidump to the provided dump file. |
| if (!MiniDumpWriteDump( |
| process.Handle(), // Process handle. |
| process.Pid(), // Process Id. |
| dump_file->GetPlatformFile(), // File handle. |
| static_cast<MINIDUMP_TYPE>(minidump_type), // Minidump type. |
| exc_info, // Exception Param |
| &user_stream_info, // UserStreamParam, |
| nullptr)) { // CallbackParam |
| return false; |
| } |
| |
| // Retouch the minidump to make it Crashpad compatible. |
| MinidumpUpdater updater; |
| if (!updater.Initialize(dump_file)) |
| return false; |
| if (!updater.AppendSimpleDictionary(crash_keys)) |
| return false; |
| |
| return true; |
| } |
| |
| // Appends the full contents of |source| to |dest| from the current position |
| // of |dest|. |
| bool AppendFileContents(base::File* source, crashpad::FileWriter* dest) { |
| DCHECK(source && source->IsValid()); |
| DCHECK(dest); |
| |
| // Rewind the source. |
| if (source->Seek(base::File::FROM_BEGIN, 0) == -1) |
| return false; |
| |
| std::vector<char> buf; |
| buf.resize(1024); |
| while (true) { |
| int bytes_read = |
| source->ReadAtCurrentPos(&buf[0], static_cast<int>(buf.size())); |
| if (bytes_read < 0) |
| return false; |
| if (bytes_read == 0) |
| break; |
| |
| if (!dest->Write(&buf[0], static_cast<size_t>(bytes_read))) { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| } // namespace |
| |
| bool DumpAndReportProcess(const base::Process& process, |
| uint32_t minidump_type, |
| MINIDUMP_EXCEPTION_INFORMATION* exc_info, |
| const StringStringMap& crash_keys, |
| const base::FilePath& crashpad_database_path) { |
| std::unique_ptr<crashpad::CrashReportDatabase> database = |
| crashpad::CrashReportDatabase::InitializeWithoutCreating( |
| crashpad_database_path); |
| |
| if (!database) |
| return false; |
| |
| std::unique_ptr<crashpad::CrashReportDatabase::NewReport> report; |
| crashpad::CrashReportDatabase::OperationStatus status = |
| database->PrepareNewCrashReport(&report); |
| if (status != crashpad::CrashReportDatabase::kNoError) |
| return false; |
| |
| crashpad::UUID client_id; |
| crashpad::Settings* settings = database->GetSettings(); |
| if (settings) { |
| // If GetSettings() or GetClientID() fails client_id will be left at its |
| // default value, all zeroes, which is appropriate. |
| settings->GetClientID(&client_id); |
| } |
| |
| base::FilePath dump_file_path; |
| if (!base::CreateTemporaryFile(&dump_file_path)) |
| return false; |
| |
| // Open the file with delete on close, to try and ensure it's cleaned up on |
| // any kind of failure. |
| base::File dump_file(dump_file_path, base::File::FLAG_OPEN | |
| base::File::FLAG_READ | |
| base::File::FLAG_WRITE | |
| base::File::FLAG_DELETE_ON_CLOSE); |
| if (!dump_file.IsValid()) |
| return false; |
| |
| // Write the minidump to the temp file, and then copy the data to the |
| // Crashpad-provided handle, as the latter is only open for write. |
| if (!MiniDumpWriteDumpWithCrashpadInfo(process, minidump_type, exc_info, |
| crash_keys, client_id, |
| report->ReportID(), &dump_file) || |
| !AppendFileContents(&dump_file, report->Writer())) { |
| return false; |
| } |
| |
| crashpad::UUID report_id = {}; |
| status = database->FinishedWritingCrashReport(std::move(report), &report_id); |
| if (status != crashpad::CrashReportDatabase::kNoError) |
| return false; |
| |
| return true; |
| } |
| |
| } // namespace crash_reporter |