OLD | NEW |
(Empty) | |
| 1 // Copyright 2014 The Crashpad Authors. All rights reserved. |
| 2 // |
| 3 // Licensed under the Apache License, Version 2.0 (the "License"); |
| 4 // you may not use this file except in compliance with the License. |
| 5 // You may obtain a copy of the License at |
| 6 // |
| 7 // http://www.apache.org/licenses/LICENSE-2.0 |
| 8 // |
| 9 // Unless required by applicable law or agreed to in writing, software |
| 10 // distributed under the License is distributed on an "AS IS" BASIS, |
| 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 12 // See the License for the specific language governing permissions and |
| 13 // limitations under the License. |
| 14 |
| 15 #include "minidump/minidump_system_info_writer.h" |
| 16 |
| 17 #include <string.h> |
| 18 |
| 19 #include "base/logging.h" |
| 20 #include "minidump/minidump_string_writer.h" |
| 21 |
| 22 namespace crashpad { |
| 23 |
| 24 MinidumpSystemInfoWriter::MinidumpSystemInfoWriter() |
| 25 : MinidumpStreamWriter(), system_info_(), csd_version_() { |
| 26 system_info_.ProcessorArchitecture = kMinidumpCPUArchitectureUnknown; |
| 27 } |
| 28 |
| 29 MinidumpSystemInfoWriter::~MinidumpSystemInfoWriter() { |
| 30 } |
| 31 |
| 32 void MinidumpSystemInfoWriter::SetCSDVersion(const std::string& csd_version) { |
| 33 DCHECK_EQ(state(), kStateMutable); |
| 34 |
| 35 if (!csd_version_) { |
| 36 csd_version_.reset(new internal::MinidumpUTF16StringWriter()); |
| 37 } |
| 38 |
| 39 csd_version_->SetUTF8(csd_version); |
| 40 } |
| 41 |
| 42 void MinidumpSystemInfoWriter::SetCPUX86Vendor(uint32_t ebx, |
| 43 uint32_t edx, |
| 44 uint32_t ecx) { |
| 45 DCHECK_EQ(state(), kStateMutable); |
| 46 DCHECK(system_info_.ProcessorArchitecture == kMinidumpCPUArchitectureX86 || |
| 47 system_info_.ProcessorArchitecture == |
| 48 kMinidumpCPUArchitectureX86Win64); |
| 49 |
| 50 COMPILE_ASSERT(arraysize(system_info_.Cpu.X86CpuInfo.VendorId) == 3, |
| 51 vendor_id_must_have_3_elements); |
| 52 |
| 53 system_info_.Cpu.X86CpuInfo.VendorId[0] = ebx; |
| 54 system_info_.Cpu.X86CpuInfo.VendorId[1] = edx; |
| 55 system_info_.Cpu.X86CpuInfo.VendorId[2] = ecx; |
| 56 } |
| 57 |
| 58 void MinidumpSystemInfoWriter::SetCPUX86VendorString( |
| 59 const std::string& vendor) { |
| 60 DCHECK_EQ(state(), kStateMutable); |
| 61 CHECK_EQ(vendor.size(), sizeof(system_info_.Cpu.X86CpuInfo.VendorId)); |
| 62 |
| 63 uint32_t registers[3]; |
| 64 COMPILE_ASSERT( |
| 65 sizeof(registers) == sizeof(system_info_.Cpu.X86CpuInfo.VendorId), |
| 66 vendor_id_sizes_must_be_equal); |
| 67 |
| 68 for (size_t index = 0; index < arraysize(registers); ++index) { |
| 69 memcpy(®isters[index], |
| 70 &vendor[index * sizeof(*registers)], |
| 71 sizeof(*registers)); |
| 72 } |
| 73 |
| 74 SetCPUX86Vendor(registers[0], registers[1], registers[2]); |
| 75 } |
| 76 |
| 77 void MinidumpSystemInfoWriter::SetCPUX86VersionAndFeatures(uint32_t version, |
| 78 uint32_t features) { |
| 79 DCHECK_EQ(state(), kStateMutable); |
| 80 DCHECK(system_info_.ProcessorArchitecture == kMinidumpCPUArchitectureX86 || |
| 81 system_info_.ProcessorArchitecture == |
| 82 kMinidumpCPUArchitectureX86Win64); |
| 83 |
| 84 system_info_.Cpu.X86CpuInfo.VersionInformation = version; |
| 85 system_info_.Cpu.X86CpuInfo.FeatureInformation = features; |
| 86 } |
| 87 |
| 88 void MinidumpSystemInfoWriter::SetCPUX86AMDExtendedFeatures( |
| 89 uint32_t extended_features) { |
| 90 DCHECK_EQ(state(), kStateMutable); |
| 91 DCHECK(system_info_.ProcessorArchitecture == kMinidumpCPUArchitectureX86 || |
| 92 system_info_.ProcessorArchitecture == |
| 93 kMinidumpCPUArchitectureX86Win64); |
| 94 DCHECK(system_info_.Cpu.X86CpuInfo.VendorId[0] == 'htuA' && |
| 95 system_info_.Cpu.X86CpuInfo.VendorId[1] == 'itne' && |
| 96 system_info_.Cpu.X86CpuInfo.VendorId[2] == 'DMAc'); |
| 97 |
| 98 system_info_.Cpu.X86CpuInfo.AMDExtendedCpuFeatures = extended_features; |
| 99 } |
| 100 |
| 101 void MinidumpSystemInfoWriter::SetCPUOtherFeatures(uint64_t features_0, |
| 102 uint64_t features_1) { |
| 103 DCHECK_EQ(state(), kStateMutable); |
| 104 DCHECK(system_info_.ProcessorArchitecture != kMinidumpCPUArchitectureX86 && |
| 105 system_info_.ProcessorArchitecture != |
| 106 kMinidumpCPUArchitectureX86Win64); |
| 107 |
| 108 COMPILE_ASSERT( |
| 109 arraysize(system_info_.Cpu.OtherCpuInfo.ProcessorFeatures) == 2, |
| 110 processor_features_must_have_2_elements); |
| 111 |
| 112 system_info_.Cpu.OtherCpuInfo.ProcessorFeatures[0] = features_0; |
| 113 system_info_.Cpu.OtherCpuInfo.ProcessorFeatures[1] = features_1; |
| 114 } |
| 115 |
| 116 bool MinidumpSystemInfoWriter::Freeze() { |
| 117 DCHECK_EQ(state(), kStateMutable); |
| 118 CHECK(csd_version_); |
| 119 |
| 120 if (!MinidumpStreamWriter::Freeze()) { |
| 121 return false; |
| 122 } |
| 123 |
| 124 csd_version_->RegisterRVA(&system_info_.CSDVersionRva); |
| 125 |
| 126 return true; |
| 127 } |
| 128 |
| 129 size_t MinidumpSystemInfoWriter::SizeOfObject() { |
| 130 DCHECK_GE(state(), kStateFrozen); |
| 131 |
| 132 return sizeof(system_info_); |
| 133 } |
| 134 |
| 135 std::vector<internal::MinidumpWritable*> MinidumpSystemInfoWriter::Children() { |
| 136 DCHECK_GE(state(), kStateFrozen); |
| 137 DCHECK(csd_version_); |
| 138 |
| 139 std::vector<MinidumpWritable*> children(1, csd_version_.get()); |
| 140 return children; |
| 141 } |
| 142 |
| 143 bool MinidumpSystemInfoWriter::WriteObject(FileWriterInterface* file_writer) { |
| 144 DCHECK_EQ(state(), kStateWritable); |
| 145 |
| 146 return file_writer->Write(&system_info_, sizeof(system_info_)); |
| 147 } |
| 148 |
| 149 MinidumpStreamType MinidumpSystemInfoWriter::StreamType() const { |
| 150 return kMinidumpStreamTypeSystemInfo; |
| 151 } |
| 152 |
| 153 } // namespace crashpad |
OLD | NEW |