dmp文件分析（二）- symbol

 1bool Stackwalker::Walk(
 2    CallStack* stack,
 3    vector<const CodeModule*>* modules_without_symbols,
 4    vector<const CodeModule*>* modules_with_corrupt_symbols) {
 5  ...
 6  // 构造一个栈帧，并取出context中的寄存器的eip，并缓存下来
 7  scoped_ptr<StackFrame> frame(GetContextFrame());
 8
 9  // 这里是一个死循环，一直分析并提取堆栈，直到下一个栈帧为空
10  while (frame.get()) {
11    // 栈帧始终包含一个有效的调用栈信息，并设置指令地址
12    // 指令地址来自context中的eip，或者被调用者
13
14    // 提取symbol信息，协助分析
15    StackFrameSymbolizer::SymbolizerResult symbolizer_result =
16        frame_symbolizer_->FillSourceLineInfo(modules_, unloaded_modules_,
17                                              system_info_,
18    // 添加分析完毕的栈帧信息到堆栈列表中
19    stack->frames_.push_back(frame.release());
20
21    // 获取下一个栈帧（调用者的栈帧）
22    bool stack_scan_allowed = scanned_frames < max_frames_scanned_;
23
24    // 栈帧回溯的核心方法：GetCallerFrame
25    frame.reset(GetCallerFrame(stack, stack_scan_allowed));
26  }
27
28  return true;
29}

1MODULE windows x86 3AA3B2229C144C24AEBEF3D971F32D711 GMTSJWorker.pdb
2FILE 18430 d:\winmain.public.x86fre\sdk\inc\rpcdce.h
3FUNC b7990 49 0 `dynamic initializer for 'std::_Error_objects<int>::_Generic_object''
4b7990 49 611 282
5FUNC c2a70 327 0 boost::algorithm::detail::process_segment_helper<0>::operator()<std::deque<wchar_t,std::allocator<wchar_t> >,std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t> >,std::_String_iterator<std::_String_val<std::_Simple_types<wchar_t> > > >(std::deque<wchar_t,std::allocator<wchar_t> > &,std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t> > &,std::_String_iterator<std::_String_val<std::_Simple_types<wchar_t> > >,std::_String_iterator<std::_String_val<std::_Simple_types<wchar_t> > >,std::_String_iterator<std::_String_val<std::_Simple_types<wchar_t> > >)
6c2a70 53 63 6337
7c2ac3 62 71 6337
8STACK WIN 4 207410 f 3 0 0 0 0 0 1 $T0 $ebp = $eip $T0 4 + ^ = $ebp $T0 ^ = $esp $T0 8 + =

1msvcp100.amd64.pdb/FAE62411E45D4218AB9761C4E55F64791/msvcp100.amd64.sym

 1StackFrameSymbolizer::SymbolizerResult StackFrameSymbolizer::FillSourceLineInfo(
 2    const CodeModules* modules,
 3    const CodeModules* unloaded_modules,
 4    const SystemInfo* system_info,
 5    StackFrame* frame) {
 6
 7  const CodeModule* module = NULL;
 8  if (modules) {
 9    // frame->instruction就是上一篇介绍到的，从寄存器中获取的eip指令地址
10    // eip寄存器，用来存储CPU要读取指令的地址
11    // 崩溃的时候，eip存放的地址，就是崩溃时的指令地址
12    // 这里根据eip指令的地址，去modules列表中去匹配相关的module，确定在哪个module崩溃了
13    // 分析module的读取时，我们说过，modules中根据模块的内存地址，建立了RangeMap的索引
14    //     在这里，就能快速定位到当前指令是在哪个模块执行时崩溃的
15    module = modules->GetModuleForAddress(frame->instruction);
16  }
17  // 如果加载的模块内存，匹配不到eip指令，就去未加载的模块中去匹配
18  if (!module && unloaded_modules) {
19    module = unloaded_modules->GetModuleForAddress(frame->instruction);
20  }
21
22  // 找到模块后，保存到当前分析的栈帧中
23  frame->module = module;
24
25  // 每个module，都会尝试去匹配module相关的symbol信息，
26  // 如果找不到symbol信息，就放到无symbol的名单中，下次就不用再尝试去找了
27  if (no_symbol_modules_.find(module->code_file()) !=
28      no_symbol_modules_.end()) {
29    return kError;
30  }
31
32  // resolver_保存了所有已经和symbol信息关联上的module列表
33  // 首先判断该模块是否加载过symol了，如果加载过，直接将symbol中的代码行数信息进行填充
34  if (resolver_->HasModule(frame->module)) {
35    resolver_->FillSourceLineInfo(frame);
36    return resolver_->IsModuleCorrupt(frame->module) ?
37        kWarningCorruptSymbols : kNoError;
38  }
39
40  // 如果module和symbol还没有做过关联，开始尝试去提取symbol
41  string symbol_file;
42  char* symbol_data = NULL;
43  size_t symbol_data_size;
44
45  // 这里是提取symbol的核心方法
46  // 判断给定的symbol路径下，有没有和moduel匹配的sym信息
47  // 并不是暴力搜索，而是按照规则去匹配
48  SymbolSupplier::SymbolResult symbol_result = supplier_->GetCStringSymbolData(
49      module, system_info, &symbol_file, &symbol_data, &symbol_data_size);
50  // 处理匹配结果
51  switch (symbol_result) {
52    case SymbolSupplier::FOUND: {
53      // 成功找到symbol信息，symbol_data中保存的是读取到symbol文本内容
54      // 使用symbol内容做下一步操作
55      bool load_success = resolver_->LoadModuleUsingMemoryBuffer(
56          frame->module,
57          symbol_data,
58          symbol_data_size);
59      if (resolver_->ShouldDeleteMemoryBufferAfterLoadModule()) {
60        supplier_->FreeSymbolData(module);
61      }
62      // 加载成功，填充源码信息到结果中
63      if (load_success) {
64        resolver_->FillSourceLineInfo(frame);
65        return resolver_->IsModuleCorrupt(frame->module) ?
66            kWarningCorruptSymbols : kNoError;
67      } else {
68        // 加载失败，认为该模块是无法匹配symbol的，下次就不用再分析这个module了
69        no_symbol_modules_.insert(module->code_file());
70        return kError;
71      }
72    }
73
74    case SymbolSupplier::NOT_FOUND:
75    // 匹配不到符号文件，认为该模块是无法匹配symbol的，下次就不用再分析这个module了
76      no_symbol_modules_.insert(module->code_file());
77      return kError;
78
79    case SymbolSupplier::INTERRUPT:
80      return kInterrupt;
81
82    default:
83      BPLOG(ERROR) << "Unknown SymbolResult enum: " << symbol_result;
84      return kError;
85  }
86  return kError;
87}

 1SymbolSupplier::SymbolResult SimpleSymbolSupplier::GetCStringSymbolData(
 2    const CodeModule *module,
 3    const SystemInfo *system_info,
 4    string *symbol_file,
 5    char **symbol_data,
 6    size_t *symbol_data_size) {
 7
 8  // 调用GetSymbolFile方法去找符号信息
 9  string symbol_data_string;
10  SymbolSupplier::SymbolResult s =
11      GetSymbolFile(module, system_info, symbol_file, &symbol_data_string);
12
13  // 如果找到符号信息，将读取的字符串保存
14  if (s == FOUND) {
15    *symbol_data_size = symbol_data_string.size() + 1;
16    *symbol_data = new char[*symbol_data_size];
17    if (*symbol_data == NULL) {
18      BPLOG(ERROR) << "Memory allocation for size " << *symbol_data_size
19                   << " failed";
20      return INTERRUPT;
21    }
22    memcpy(*symbol_data, symbol_data_string.c_str(), symbol_data_string.size());
23    (*symbol_data)[symbol_data_string.size()] = '\0';
24    // 将符号信息缓存下来，key为模块的完整路径名，value为symbol信息
25    memory_buffers_.insert(make_pair(module->code_file(), *symbol_data));
26  }
27  return s;
28}

 1SymbolSupplier::SymbolResult SimpleSymbolSupplier::GetSymbolFile(
 2    const CodeModule *module, const SystemInfo *system_info,
 3    string *symbol_file) {
 4
 5  // minidump_stackwalk传symbol路径时，可以传入多个
 6  // 遍历所有的symbol路径
 7  for (unsigned int path_index = 0; path_index < paths_.size(); ++path_index) {
 8    SymbolResult result;
 9    // 针对每个路径，调用符号查找方法
10    // 如果找到了，直接返回不再继续查找
11    if ((result = GetSymbolFileAtPathFromRoot(module, system_info,
12                                              paths_[path_index],
13                                              symbol_file)) != NOT_FOUND) {
14      return result;
15    }
16  }
17  return NOT_FOUND;
18}

 1SymbolSupplier::SymbolResult SimpleSymbolSupplier::GetSymbolFileAtPathFromRoot(
 2    const CodeModule *module, const SystemInfo *system_info,
 3    const string &root_path, string *symbol_file) {
 4
 5  // 拼接查找路径
 6  string path = root_path;
 7  path.append("/");
 8  // 获取模块的debug_file，具体到windows平台，就是module.pdb, 比如msvcp100.pdb
 9  string debug_file_name = PathnameStripper::File(module->debug_file());
10  // 获取模块的唯一标识
11  string identifier = module->debug_identifier();
12  if (debug_file_name.empty()) {
13    BPLOG(ERROR) << "Can't construct symbol file path without debug_file "
14                    "(code_file = " <<
15                    PathnameStripper::File(module->code_file()) << ")";
16    return NOT_FOUND;
17  }
18  path.append(debug_file_name);
19
20  // Append the identifier as a directory name.
21  path.append("/");
22
23  // 如果唯一标识为空，直接返回错误，认为这个symbol找不到
24  if (identifier.empty()) {
25    return NOT_FOUND;
26  }
27  path.append(identifier);
28
29  // 获取debug_file名称，如果后缀为.pdb，将后缀改为.sym
30  path.append("/");
31  string debug_file_extension;
32  if (debug_file_name.size() > 4)
33    debug_file_extension = debug_file_name.substr(debug_file_name.size() - 4);
34  std::transform(debug_file_extension.begin(), debug_file_extension.end(),
35                 debug_file_extension.begin(), tolower);
36  if (debug_file_extension == ".pdb") {
37    path.append(debug_file_name.substr(0, debug_file_name.size() - 4));
38  } else {
39    path.append(debug_file_name);
40  }
41  path.append(".sym");
42
43  // 判断文件是否存在，不存在直接返回找不到
44  if (!file_exists(path)) {
45    BPLOG(INFO) << "No symbol file at " << path;
46    return NOT_FOUND;
47  }
48
49  // 路径存在，说明成功找到symbol
50  *symbol_file = path;
51  return FOUND;
52}

 1bool SourceLineResolverBase::LoadModuleUsingMemoryBuffer(
 2    const CodeModule *module,
 3    char *memory_buffer,
 4    size_t memory_buffer_size) {
 5  // 工厂方法构造一个Module子类，用于接收symbol读取后的文本，并转换成对象
 6  Module *basic_module = module_factory_->CreateModule(module->code_file());
 7
 8  // 将symbol文本格式转换为特定的模型
 9  if (!basic_module->LoadMapFromMemory(memory_buffer, memory_buffer_size)) {
10    BPLOG(ERROR) << "Too many error while parsing symbol data for module "
11                 << module->code_file();
12    assert(basic_module->IsCorrupt());
13  }
14
15  modules_->insert(make_pair(module->code_file(), basic_module));
16}

  1bool BasicSourceLineResolver::Module::LoadMapFromMemory(
  2    char *memory_buffer,
  3    size_t memory_buffer_size) {
  4
  5  // 首先确保字符串末尾以‘\n`结尾
  6  size_t last_null_terminator = memory_buffer_size - 1;
  7  if (memory_buffer[last_null_terminator] != '\0') {
  8    memory_buffer[last_null_terminator] = '\0';
  9  }
 10
 11  // 跳过所有的'\n'字符（除了末尾的）
 12  // 并且确保读取的symbol字符串没有'\n'，有的都替换为‘_'
 13  bool has_null_terminator_in_the_middle = false;
 14  while (last_null_terminator > 0 &&
 15         memory_buffer[last_null_terminator - 1] == '\0') {
 16    last_null_terminator--;
 17  }
 18  for (size_t i = 0; i < last_null_terminator; i++) {
 19    if (memory_buffer[i] == '\0') {
 20      memory_buffer[i] = '_';
 21      has_null_terminator_in_the_middle = true;
 22    }
 23  }
 24  // 如果有‘\n’字符在中间，抛出错误提示信息
 25  if (has_null_terminator_in_the_middle) {
 26    LogParseError(
 27       "Null terminator is not expected in the middle of the symbol data",
 28       line_number,
 29       &num_errors);
 30  }
 31
 32  // 将文本字符串按照'\r\n'做切割，就是按行切割成字符串列表
 33  char *buffer;
 34  buffer = strtok_r(memory_buffer, "\r\n", &save_ptr);
 35
 36  // 遍历所有行
 37  while (buffer != NULL) {
 38    ++line_number;
 39
 40    // 解析symbol中的 FILE（前5个字符是FILE）
 41    if (strncmp(buffer, "FILE ", 5) == 0) {
 42      // 将FILE字符串转换为对象,并保存到一个保存File信息的RangeMap中
 43      if (!ParseFile(buffer)) {
 44        LogParseError("ParseFile on buffer failed", line_number, &num_errors);
 45      }
 46    }else if (strncmp(buffer, "STACK ", 6) == 0) {
 47      // 处理 symbole中的 STACK（前六个字符是STACK）
 48      if (!ParseStackInfo(buffer)) {
 49        LogParseError("ParseStackInfo failed", line_number, &num_errors);
 50      }
 51    } else if (strncmp(buffer, "FUNC ", 5) == 0) {
 52      // 处理 symbole中的 FUNC（前五个字符是STACK）
 53      cur_func.reset(ParseFunction(buffer));
 54      if (!cur_func.get()) {
 55        LogParseError("ParseFunction failed", line_number, &num_errors);
 56      } else {
 57        // StoreRange will fail if the function has an invalid address or size.
 58        // We'll silently ignore this, the function and any corresponding lines
 59        // will be destroyed when cur_func is released.
 60        functions_.StoreRange(cur_func->address, cur_func->size, cur_func);
 61      }
 62    } else if (strncmp(buffer, "PUBLIC ", 7) == 0) {
 63      // 处理 symbole中的 FUNC（前五个字符是STACK）
 64      // Clear cur_func: public symbols don't contain line number information.
 65      cur_func.reset();
 66
 67      if (!ParsePublicSymbol(buffer)) {
 68        LogParseError("ParsePublicSymbol failed", line_number, &num_errors);
 69      }
 70    } else if (strncmp(buffer, "MODULE ", 7) == 0) {
 71      // 处理 symbole中的 MODULE（前7个字符是MODULE）
 72      // 忽略不处理，没有崩溃的有用信息
 73      // 主要用来做唯一标识，格式如下：
 74      // MODULE <guid> <age> <filename>
 75    } else if (strncmp(buffer, "INFO ", 5) == 0) {
 76      // 处理 symbole中的 INFO（前5个字符是INFO）
 77      // 忽略不处理，没有崩溃的有用信息，格式如下：
 78      // INFO CODE_ID <code id> <filename>
 79    } else {
 80      if (!cur_func.get()) {
 81        LogParseError("Found source line data without a function",
 82                       line_number, &num_errors);
 83      } else {
 84        Line *line = ParseLine(buffer);
 85        if (!line) {
 86          LogParseError("ParseLine failed", line_number, &num_errors);
 87        } else {
 88          cur_func->lines.StoreRange(line->address, line->size,
 89                                     linked_ptr<Line>(line));
 90        }
 91      }
 92    }
 93    if (num_errors > kMaxErrorsBeforeBailing) {
 94      break;
 95    }
 96    buffer = strtok_r(NULL, "\r\n", &save_ptr);
 97  }
 98  is_corrupt_ = num_errors > 0;
 99  return true;
100}

 1void SourceLineResolverBase::FillSourceLineInfo(StackFrame *frame) {
 2  if (frame->module) {
 3    ModuleMap::const_iterator it = modules_->find(frame->module->code_file());
 4    if (it != modules_->end()) {
 5      it->second->LookupAddress(frame);
 6    }
 7  }
 8}
 9
10void BasicSourceLineResolver::Module::LookupAddress(StackFrame *frame) const {
11  MemAddr address = frame->instruction - frame->module->base_address();
12
13  // First, look for a FUNC record that covers address. Use
14  // RetrieveNearestRange instead of RetrieveRange so that, if there
15  // is no such function, we can use the next function to bound the
16  // extent of the PUBLIC symbol we find, below. This does mean we
17  // need to check that address indeed falls within the function we
18  // find; do the range comparison in an overflow-friendly way.
19  linked_ptr<Function> func;
20  linked_ptr<PublicSymbol> public_symbol;
21  MemAddr function_base;
22  MemAddr function_size;
23  MemAddr public_address;
24  if (functions_.RetrieveNearestRange(address, &func, &function_base,
25                                      NULL /* delta */, &function_size) &&
26      address >= function_base && address - function_base < function_size) {
27    frame->function_name = func->name;
28    frame->function_base = frame->module->base_address() + function_base;
29
30    linked_ptr<Line> line;
31    MemAddr line_base;
32    if (func->lines.RetrieveRange(address, &line, &line_base, NULL /* delta */,
33                                  NULL /* size */)) {
34      FileMap::const_iterator it = files_.find(line->source_file_id);
35      if (it != files_.end()) {
36        frame->source_file_name = files_.find(line->source_file_id)->second;
37      }
38      frame->source_line = line->line;
39      frame->source_line_base = frame->module->base_address() + line_base;
40    }
41  } else if (public_symbols_.Retrieve(address,
42                                      &public_symbol, &public_address) &&
43             (!func.get() || public_address > function_base)) {
44    frame->function_name = public_symbol->name;
45    frame->function_base = frame->module->base_address() + public_address;
46  }
47}