1 // Copyright (c) 2010 Google Inc.
2 // All rights reserved.
3 //
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are
6 // met:
7 //
8 // * Redistributions of source code must retain the above copyright
9 // notice, this list of conditions and the following disclaimer.
10 // * Redistributions in binary form must reproduce the above
11 // copyright notice, this list of conditions and the following disclaimer
12 // in the documentation and/or other materials provided with the
13 // distribution.
14 // * Neither the name of Google Inc. nor the names of its
15 // contributors may be used to endorse or promote products derived from
16 // this software without specific prior written permission.
17 //
18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 //
30 // source_line_resolver_base.cc: Implementation of SourceLineResolverBase.
31 //
32 // See source_line_resolver_base.h and source_line_resolver_base_types.h for
33 // more documentation.
34 //
35 // Author: Siyang Xie (lambxsy@google.com)
36
37 #include <stdio.h>
38 #include <string.h>
39 #include <sys/stat.h>
40
41 #include <map>
42 #include <utility>
43
44 #include "google_breakpad/processor/source_line_resolver_base.h"
45 #include "processor/source_line_resolver_base_types.h"
46 #include "processor/module_factory.h"
47
48 using std::map;
49 using std::make_pair;
50
51 namespace google_breakpad {
52
SourceLineResolverBase(ModuleFactory * module_factory)53 SourceLineResolverBase::SourceLineResolverBase(
54 ModuleFactory *module_factory)
55 : modules_(new ModuleMap),
56 corrupt_modules_(new ModuleSet),
57 memory_buffers_(new MemoryMap),
58 module_factory_(module_factory) {
59 }
60
~SourceLineResolverBase()61 SourceLineResolverBase::~SourceLineResolverBase() {
62 ModuleMap::iterator it;
63 // Iterate through ModuleMap and delete all loaded modules.
64 for (it = modules_->begin(); it != modules_->end(); ++it) {
65 // Delete individual module.
66 delete it->second;
67 }
68 // Delete the map of modules.
69 delete modules_;
70 modules_ = NULL;
71
72 // Delete the set of corrupt modules.
73 delete corrupt_modules_;
74 corrupt_modules_ = NULL;
75
76 MemoryMap::iterator iter = memory_buffers_->begin();
77 for (; iter != memory_buffers_->end(); ++iter) {
78 delete [] iter->second;
79 }
80 // Delete the map of memory buffers.
81 delete memory_buffers_;
82 memory_buffers_ = NULL;
83
84 delete module_factory_;
85 module_factory_ = NULL;
86 }
87
ReadSymbolFile(const string & map_file,char ** symbol_data,size_t * symbol_data_size)88 bool SourceLineResolverBase::ReadSymbolFile(const string &map_file,
89 char **symbol_data,
90 size_t *symbol_data_size) {
91 if (symbol_data == NULL || symbol_data_size == NULL) {
92 BPLOG(ERROR) << "Could not Read file into Null memory pointer";
93 return false;
94 }
95
96 struct stat buf;
97 int error_code = stat(map_file.c_str(), &buf);
98 if (error_code == -1) {
99 string error_string;
100 error_code = ErrnoString(&error_string);
101 BPLOG(ERROR) << "Could not open " << map_file <<
102 ", error " << error_code << ": " << error_string;
103 return false;
104 }
105
106 off_t file_size = buf.st_size;
107
108 // Allocate memory for file contents, plus a null terminator
109 // since we may use strtok() on the contents.
110 *symbol_data_size = file_size + 1;
111 *symbol_data = new char[file_size + 1];
112
113 if (*symbol_data == NULL) {
114 BPLOG(ERROR) << "Could not allocate memory for " << map_file;
115 return false;
116 }
117
118 BPLOG(INFO) << "Opening " << map_file;
119
120 FILE *f = fopen(map_file.c_str(), "rt");
121 if (!f) {
122 string error_string;
123 error_code = ErrnoString(&error_string);
124 BPLOG(ERROR) << "Could not open " << map_file <<
125 ", error " << error_code << ": " << error_string;
126 delete [] (*symbol_data);
127 *symbol_data = NULL;
128 return false;
129 }
130
131 AutoFileCloser closer(f);
132
133 int items_read = 0;
134
135 items_read = fread(*symbol_data, 1, file_size, f);
136
137 if (items_read != file_size) {
138 string error_string;
139 error_code = ErrnoString(&error_string);
140 BPLOG(ERROR) << "Could not slurp " << map_file <<
141 ", error " << error_code << ": " << error_string;
142 delete [] (*symbol_data);
143 *symbol_data = NULL;
144 return false;
145 }
146
147 (*symbol_data)[file_size] = '\0';
148 return true;
149 }
150
LoadModule(const CodeModule * module,const string & map_file)151 bool SourceLineResolverBase::LoadModule(const CodeModule *module,
152 const string &map_file) {
153 if (module == NULL)
154 return false;
155
156 // Make sure we don't already have a module with the given name.
157 if (modules_->find(module->code_file()) != modules_->end()) {
158 BPLOG(INFO) << "Symbols for module " << module->code_file()
159 << " already loaded";
160 return false;
161 }
162
163 BPLOG(INFO) << "Loading symbols for module " << module->code_file()
164 << " from " << map_file;
165
166 char *memory_buffer;
167 size_t memory_buffer_size;
168 if (!ReadSymbolFile(map_file, &memory_buffer, &memory_buffer_size))
169 return false;
170
171 BPLOG(INFO) << "Read symbol file " << map_file << " succeeded";
172
173 bool load_result = LoadModuleUsingMemoryBuffer(module, memory_buffer,
174 memory_buffer_size);
175
176 if (load_result && !ShouldDeleteMemoryBufferAfterLoadModule()) {
177 // memory_buffer has to stay alive as long as the module.
178 memory_buffers_->insert(make_pair(module->code_file(), memory_buffer));
179 } else {
180 delete [] memory_buffer;
181 }
182
183 return load_result;
184 }
185
LoadModuleUsingMapBuffer(const CodeModule * module,const string & map_buffer)186 bool SourceLineResolverBase::LoadModuleUsingMapBuffer(
187 const CodeModule *module, const string &map_buffer) {
188 if (module == NULL)
189 return false;
190
191 // Make sure we don't already have a module with the given name.
192 if (modules_->find(module->code_file()) != modules_->end()) {
193 BPLOG(INFO) << "Symbols for module " << module->code_file()
194 << " already loaded";
195 return false;
196 }
197
198 size_t memory_buffer_size = map_buffer.size() + 1;
199 char *memory_buffer = new char[memory_buffer_size];
200 if (memory_buffer == NULL) {
201 BPLOG(ERROR) << "Could not allocate memory for " << module->code_file();
202 return false;
203 }
204
205 // Can't use strcpy, as the data may contain '\0's before the end.
206 memcpy(memory_buffer, map_buffer.c_str(), map_buffer.size());
207 memory_buffer[map_buffer.size()] = '\0';
208
209 bool load_result = LoadModuleUsingMemoryBuffer(module, memory_buffer,
210 memory_buffer_size);
211
212 if (load_result && !ShouldDeleteMemoryBufferAfterLoadModule()) {
213 // memory_buffer has to stay alive as long as the module.
214 memory_buffers_->insert(make_pair(module->code_file(), memory_buffer));
215 } else {
216 delete [] memory_buffer;
217 }
218
219 return load_result;
220 }
221
LoadModuleUsingMemoryBuffer(const CodeModule * module,char * memory_buffer,size_t memory_buffer_size)222 bool SourceLineResolverBase::LoadModuleUsingMemoryBuffer(
223 const CodeModule *module,
224 char *memory_buffer,
225 size_t memory_buffer_size) {
226 if (!module)
227 return false;
228
229 // Make sure we don't already have a module with the given name.
230 if (modules_->find(module->code_file()) != modules_->end()) {
231 BPLOG(INFO) << "Symbols for module " << module->code_file()
232 << " already loaded";
233 return false;
234 }
235
236 BPLOG(INFO) << "Loading symbols for module " << module->code_file()
237 << " from memory buffer";
238
239 Module *basic_module = module_factory_->CreateModule(module->code_file());
240
241 // Ownership of memory is NOT transfered to Module::LoadMapFromMemory().
242 if (!basic_module->LoadMapFromMemory(memory_buffer, memory_buffer_size)) {
243 BPLOG(ERROR) << "Too many error while parsing symbol data for module "
244 << module->code_file();
245 // Returning false from here would be an indication that the symbols for
246 // this module are missing which would be wrong. Intentionally fall through
247 // and add the module to both the modules_ and the corrupt_modules_ lists.
248 assert(basic_module->IsCorrupt());
249 }
250
251 modules_->insert(make_pair(module->code_file(), basic_module));
252 if (basic_module->IsCorrupt()) {
253 corrupt_modules_->insert(module->code_file());
254 }
255 return true;
256 }
257
ShouldDeleteMemoryBufferAfterLoadModule()258 bool SourceLineResolverBase::ShouldDeleteMemoryBufferAfterLoadModule() {
259 return true;
260 }
261
UnloadModule(const CodeModule * code_module)262 void SourceLineResolverBase::UnloadModule(const CodeModule *code_module) {
263 if (!code_module)
264 return;
265
266 ModuleMap::iterator mod_iter = modules_->find(code_module->code_file());
267 if (mod_iter != modules_->end()) {
268 Module *symbol_module = mod_iter->second;
269 delete symbol_module;
270 corrupt_modules_->erase(mod_iter->first);
271 modules_->erase(mod_iter);
272 }
273
274 if (ShouldDeleteMemoryBufferAfterLoadModule()) {
275 // No-op. Because we never store any memory buffers.
276 } else {
277 // There may be a buffer stored locally, we need to find and delete it.
278 MemoryMap::iterator iter = memory_buffers_->find(code_module->code_file());
279 if (iter != memory_buffers_->end()) {
280 delete [] iter->second;
281 memory_buffers_->erase(iter);
282 }
283 }
284 }
285
HasModule(const CodeModule * module)286 bool SourceLineResolverBase::HasModule(const CodeModule *module) {
287 if (!module)
288 return false;
289 return modules_->find(module->code_file()) != modules_->end();
290 }
291
IsModuleCorrupt(const CodeModule * module)292 bool SourceLineResolverBase::IsModuleCorrupt(const CodeModule *module) {
293 if (!module)
294 return false;
295 return corrupt_modules_->find(module->code_file()) != corrupt_modules_->end();
296 }
297
FillSourceLineInfo(StackFrame * frame)298 void SourceLineResolverBase::FillSourceLineInfo(StackFrame *frame) {
299 if (frame->module) {
300 ModuleMap::const_iterator it = modules_->find(frame->module->code_file());
301 if (it != modules_->end()) {
302 it->second->LookupAddress(frame);
303 }
304 }
305 }
306
FindWindowsFrameInfo(const StackFrame * frame)307 WindowsFrameInfo *SourceLineResolverBase::FindWindowsFrameInfo(
308 const StackFrame *frame) {
309 if (frame->module) {
310 ModuleMap::const_iterator it = modules_->find(frame->module->code_file());
311 if (it != modules_->end()) {
312 return it->second->FindWindowsFrameInfo(frame);
313 }
314 }
315 return NULL;
316 }
317
FindCFIFrameInfo(const StackFrame * frame)318 CFIFrameInfo *SourceLineResolverBase::FindCFIFrameInfo(
319 const StackFrame *frame) {
320 if (frame->module) {
321 ModuleMap::const_iterator it = modules_->find(frame->module->code_file());
322 if (it != modules_->end()) {
323 return it->second->FindCFIFrameInfo(frame);
324 }
325 }
326 return NULL;
327 }
328
operator ()(const string & s1,const string & s2) const329 bool SourceLineResolverBase::CompareString::operator()(
330 const string &s1, const string &s2) const {
331 return strcmp(s1.c_str(), s2.c_str()) < 0;
332 }
333
ParseCFIRuleSet(const string & rule_set,CFIFrameInfo * frame_info) const334 bool SourceLineResolverBase::Module::ParseCFIRuleSet(
335 const string &rule_set, CFIFrameInfo *frame_info) const {
336 CFIFrameInfoParseHandler handler(frame_info);
337 CFIRuleParser parser(&handler);
338 return parser.Parse(rule_set);
339 }
340
341 } // namespace google_breakpad
342