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_module_crashpad_info_writer.h"
16
17 #include <utility>
18
19 #include "base/logging.h"
20 #include "minidump/minidump_annotation_writer.h"
21 #include "minidump/minidump_simple_string_dictionary_writer.h"
22 #include "snapshot/module_snapshot.h"
23 #include "util/file/file_writer.h"
24 #include "util/numeric/safe_assignment.h"
25
26 namespace crashpad {
27
MinidumpModuleCrashpadInfoWriter()28 MinidumpModuleCrashpadInfoWriter::MinidumpModuleCrashpadInfoWriter()
29 : MinidumpWritable(),
30 module_(),
31 list_annotations_(),
32 simple_annotations_(),
33 annotation_objects_() {
34 module_.version = MinidumpModuleCrashpadInfo::kVersion;
35 }
36
~MinidumpModuleCrashpadInfoWriter()37 MinidumpModuleCrashpadInfoWriter::~MinidumpModuleCrashpadInfoWriter() {
38 }
39
InitializeFromSnapshot(const ModuleSnapshot * module_snapshot)40 void MinidumpModuleCrashpadInfoWriter::InitializeFromSnapshot(
41 const ModuleSnapshot* module_snapshot) {
42 DCHECK_EQ(state(), kStateMutable);
43 DCHECK(!list_annotations_);
44 DCHECK(!simple_annotations_);
45
46 auto list_annotations = std::make_unique<MinidumpUTF8StringListWriter>();
47 list_annotations->InitializeFromVector(module_snapshot->AnnotationsVector());
48 if (list_annotations->IsUseful()) {
49 SetListAnnotations(std::move(list_annotations));
50 }
51
52 auto simple_annotations =
53 std::make_unique<MinidumpSimpleStringDictionaryWriter>();
54 simple_annotations->InitializeFromMap(
55 module_snapshot->AnnotationsSimpleMap());
56 if (simple_annotations->IsUseful()) {
57 SetSimpleAnnotations(std::move(simple_annotations));
58 }
59
60 auto annotation_objects = std::make_unique<MinidumpAnnotationListWriter>();
61 annotation_objects->InitializeFromList(module_snapshot->AnnotationObjects());
62 if (annotation_objects->IsUseful()) {
63 SetAnnotationObjects(std::move(annotation_objects));
64 }
65 }
66
SetListAnnotations(std::unique_ptr<MinidumpUTF8StringListWriter> list_annotations)67 void MinidumpModuleCrashpadInfoWriter::SetListAnnotations(
68 std::unique_ptr<MinidumpUTF8StringListWriter> list_annotations) {
69 DCHECK_EQ(state(), kStateMutable);
70
71 list_annotations_ = std::move(list_annotations);
72 }
73
SetSimpleAnnotations(std::unique_ptr<MinidumpSimpleStringDictionaryWriter> simple_annotations)74 void MinidumpModuleCrashpadInfoWriter::SetSimpleAnnotations(
75 std::unique_ptr<MinidumpSimpleStringDictionaryWriter> simple_annotations) {
76 DCHECK_EQ(state(), kStateMutable);
77
78 simple_annotations_ = std::move(simple_annotations);
79 }
80
SetAnnotationObjects(std::unique_ptr<MinidumpAnnotationListWriter> annotation_objects)81 void MinidumpModuleCrashpadInfoWriter::SetAnnotationObjects(
82 std::unique_ptr<MinidumpAnnotationListWriter> annotation_objects) {
83 DCHECK_EQ(state(), kStateMutable);
84
85 annotation_objects_ = std::move(annotation_objects);
86 }
87
IsUseful() const88 bool MinidumpModuleCrashpadInfoWriter::IsUseful() const {
89 return list_annotations_ || simple_annotations_ || annotation_objects_;
90 }
91
Freeze()92 bool MinidumpModuleCrashpadInfoWriter::Freeze() {
93 DCHECK_EQ(state(), kStateMutable);
94
95 if (!MinidumpWritable::Freeze()) {
96 return false;
97 }
98
99 if (list_annotations_) {
100 list_annotations_->RegisterLocationDescriptor(&module_.list_annotations);
101 }
102
103 if (simple_annotations_) {
104 simple_annotations_->RegisterLocationDescriptor(
105 &module_.simple_annotations);
106 }
107
108 if (annotation_objects_) {
109 annotation_objects_->RegisterLocationDescriptor(
110 &module_.annotation_objects);
111 }
112
113 return true;
114 }
115
SizeOfObject()116 size_t MinidumpModuleCrashpadInfoWriter::SizeOfObject() {
117 DCHECK_GE(state(), kStateFrozen);
118
119 return sizeof(module_);
120 }
121
122 std::vector<internal::MinidumpWritable*>
Children()123 MinidumpModuleCrashpadInfoWriter::Children() {
124 DCHECK_GE(state(), kStateFrozen);
125
126 std::vector<MinidumpWritable*> children;
127 if (list_annotations_) {
128 children.push_back(list_annotations_.get());
129 }
130 if (simple_annotations_) {
131 children.push_back(simple_annotations_.get());
132 }
133 if (annotation_objects_) {
134 children.push_back(annotation_objects_.get());
135 }
136
137 return children;
138 }
139
WriteObject(FileWriterInterface * file_writer)140 bool MinidumpModuleCrashpadInfoWriter::WriteObject(
141 FileWriterInterface* file_writer) {
142 DCHECK_EQ(state(), kStateWritable);
143
144 return file_writer->Write(&module_, sizeof(module_));
145 }
146
MinidumpModuleCrashpadInfoListWriter()147 MinidumpModuleCrashpadInfoListWriter::MinidumpModuleCrashpadInfoListWriter()
148 : MinidumpWritable(),
149 module_crashpad_infos_(),
150 module_crashpad_info_links_(),
151 module_crashpad_info_list_base_() {
152 }
153
~MinidumpModuleCrashpadInfoListWriter()154 MinidumpModuleCrashpadInfoListWriter::~MinidumpModuleCrashpadInfoListWriter() {
155 }
156
InitializeFromSnapshot(const std::vector<const ModuleSnapshot * > & module_snapshots)157 void MinidumpModuleCrashpadInfoListWriter::InitializeFromSnapshot(
158 const std::vector<const ModuleSnapshot*>& module_snapshots) {
159 DCHECK_EQ(state(), kStateMutable);
160 DCHECK(module_crashpad_infos_.empty());
161 DCHECK(module_crashpad_info_links_.empty());
162
163 size_t count = module_snapshots.size();
164 for (size_t index = 0; index < count; ++index) {
165 const ModuleSnapshot* module_snapshot = module_snapshots[index];
166
167 auto module = std::make_unique<MinidumpModuleCrashpadInfoWriter>();
168 module->InitializeFromSnapshot(module_snapshot);
169 if (module->IsUseful()) {
170 AddModule(std::move(module), index);
171 }
172 }
173 }
174
AddModule(std::unique_ptr<MinidumpModuleCrashpadInfoWriter> module_crashpad_info,size_t minidump_module_list_index)175 void MinidumpModuleCrashpadInfoListWriter::AddModule(
176 std::unique_ptr<MinidumpModuleCrashpadInfoWriter> module_crashpad_info,
177 size_t minidump_module_list_index) {
178 DCHECK_EQ(state(), kStateMutable);
179 DCHECK_EQ(module_crashpad_infos_.size(), module_crashpad_info_links_.size());
180
181 MinidumpModuleCrashpadInfoLink module_crashpad_info_link = {};
182 if (!AssignIfInRange(&module_crashpad_info_link.minidump_module_list_index,
183 minidump_module_list_index)) {
184 LOG(ERROR) << "minidump_module_list_index " << minidump_module_list_index
185 << " out of range";
186 return;
187 }
188
189 module_crashpad_info_links_.push_back(module_crashpad_info_link);
190 module_crashpad_infos_.push_back(std::move(module_crashpad_info));
191 }
192
IsUseful() const193 bool MinidumpModuleCrashpadInfoListWriter::IsUseful() const {
194 DCHECK_EQ(module_crashpad_infos_.size(), module_crashpad_info_links_.size());
195 return !module_crashpad_infos_.empty();
196 }
197
Freeze()198 bool MinidumpModuleCrashpadInfoListWriter::Freeze() {
199 DCHECK_EQ(state(), kStateMutable);
200 CHECK_EQ(module_crashpad_infos_.size(), module_crashpad_info_links_.size());
201
202 if (!MinidumpWritable::Freeze()) {
203 return false;
204 }
205
206 size_t module_count = module_crashpad_infos_.size();
207 if (!AssignIfInRange(&module_crashpad_info_list_base_.count, module_count)) {
208 LOG(ERROR) << "module_count " << module_count << " out of range";
209 return false;
210 }
211
212 for (size_t index = 0; index < module_count; ++index) {
213 module_crashpad_infos_[index]->RegisterLocationDescriptor(
214 &module_crashpad_info_links_[index].location);
215 }
216
217 return true;
218 }
219
SizeOfObject()220 size_t MinidumpModuleCrashpadInfoListWriter::SizeOfObject() {
221 DCHECK_GE(state(), kStateFrozen);
222 DCHECK_EQ(module_crashpad_infos_.size(), module_crashpad_info_links_.size());
223
224 return sizeof(module_crashpad_info_list_base_) +
225 module_crashpad_info_links_.size() *
226 sizeof(module_crashpad_info_links_[0]);
227 }
228
229 std::vector<internal::MinidumpWritable*>
Children()230 MinidumpModuleCrashpadInfoListWriter::Children() {
231 DCHECK_GE(state(), kStateFrozen);
232 DCHECK_EQ(module_crashpad_infos_.size(), module_crashpad_info_links_.size());
233
234 std::vector<MinidumpWritable*> children;
235 for (const auto& module : module_crashpad_infos_) {
236 children.push_back(module.get());
237 }
238
239 return children;
240 }
241
WriteObject(FileWriterInterface * file_writer)242 bool MinidumpModuleCrashpadInfoListWriter::WriteObject(
243 FileWriterInterface* file_writer) {
244 DCHECK_EQ(state(), kStateWritable);
245 DCHECK_EQ(module_crashpad_infos_.size(), module_crashpad_info_links_.size());
246
247 WritableIoVec iov;
248 iov.iov_base = &module_crashpad_info_list_base_;
249 iov.iov_len = sizeof(module_crashpad_info_list_base_);
250 std::vector<WritableIoVec> iovecs(1, iov);
251
252 if (!module_crashpad_info_links_.empty()) {
253 iov.iov_base = &module_crashpad_info_links_[0];
254 iov.iov_len = module_crashpad_info_links_.size() *
255 sizeof(module_crashpad_info_links_[0]);
256 iovecs.push_back(iov);
257 }
258
259 return file_writer->WriteIoVec(&iovecs);
260 }
261
262 } // namespace crashpad
263