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