contrib/llvm/tools/lldb/source/Plugins/Process/minidump/ProcessMinidump.cpp

   1 //===-- ProcessMinidump.cpp -------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 // Project includes
  11 #include "ProcessMinidump.h"
  12 #include "ThreadMinidump.h"
  13
  14 // Other libraries and framework includes
  15 #include "lldb/Core/Module.h"
  16 #include "lldb/Core/ModuleSpec.h"
  17 #include "lldb/Core/PluginManager.h"
  18 #include "lldb/Core/Section.h"
  19 #include "lldb/Core/State.h"
  20 #include "lldb/Target/DynamicLoader.h"
  21 #include "lldb/Target/MemoryRegionInfo.h"
  22 #include "lldb/Target/Target.h"
  23 #include "lldb/Target/UnixSignals.h"
  24 #include "lldb/Utility/DataBufferLLVM.h"
  25 #include "lldb/Utility/LLDBAssert.h"
  26 #include "lldb/Utility/Log.h"
  27
  28 #include "llvm/Support/MemoryBuffer.h"
  29 #include "llvm/Support/Threading.h"
  30
  31 // C includes
  32 // C++ includes
  33
  34 using namespace lldb_private;
  35 using namespace minidump;
  36
  37 ConstString ProcessMinidump::GetPluginNameStatic() {
  38   static ConstString g_name("minidump");
  39   return g_name;
  40 }
  41
  42 const char *ProcessMinidump::GetPluginDescriptionStatic() {
  43   return "Minidump plug-in.";
  44 }
  45
  46 lldb::ProcessSP ProcessMinidump::CreateInstance(lldb::TargetSP target_sp,
  47                                                 lldb::ListenerSP listener_sp,
  48                                                 const FileSpec *crash_file) {
  49   if (!crash_file)
  50     return nullptr;
  51
  52   lldb::ProcessSP process_sp;
  53   // Read enough data for the Minidump header
  54   constexpr size_t header_size = sizeof(MinidumpHeader);
  55   auto DataPtr =
  56       DataBufferLLVM::CreateSliceFromPath(crash_file->GetPath(), header_size, 0);
  57   if (!DataPtr)
  58     return nullptr;
  59
  60   assert(DataPtr->GetByteSize() == header_size);
  61
  62   // first, only try to parse the header, beacuse we need to be fast
  63   llvm::ArrayRef<uint8_t> HeaderBytes = DataPtr->GetData();
  64   const MinidumpHeader *header = MinidumpHeader::Parse(HeaderBytes);
  65   if (header == nullptr)
  66     return nullptr;
  67
  68   auto AllData = DataBufferLLVM::CreateSliceFromPath(crash_file->GetPath(), -1, 0);
  69   if (!AllData)
  70     return nullptr;
  71
  72   auto minidump_parser = MinidumpParser::Create(AllData);
  73   // check if the parser object is valid
  74   if (!minidump_parser)
  75     return nullptr;
  76
  77   return std::make_shared<ProcessMinidump>(target_sp, listener_sp, *crash_file,
  78                                            minidump_parser.getValue());
  79 }
  80
  81 bool ProcessMinidump::CanDebug(lldb::TargetSP target_sp,
  82                                bool plugin_specified_by_name) {
  83   return true;
  84 }
  85
  86 ProcessMinidump::ProcessMinidump(lldb::TargetSP target_sp,
  87                                  lldb::ListenerSP listener_sp,
  88                                  const FileSpec &core_file,
  89                                  MinidumpParser minidump_parser)
  90     : Process(target_sp, listener_sp), m_minidump_parser(minidump_parser),
  91       m_core_file(core_file), m_is_wow64(false) {}
  92
  93 ProcessMinidump::~ProcessMinidump() {
  94   Clear();
  95   // We need to call finalize on the process before destroying ourselves
  96   // to make sure all of the broadcaster cleanup goes as planned. If we
  97   // destruct this class, then Process::~Process() might have problems
  98   // trying to fully destroy the broadcaster.
  99   Finalize();
 100 }
 101
 102 void ProcessMinidump::Initialize() {
 103   static llvm::once_flag g_once_flag;
 104
 105   llvm::call_once(g_once_flag, []() {
 106     PluginManager::RegisterPlugin(GetPluginNameStatic(),
 107                                   GetPluginDescriptionStatic(),
 108                                   ProcessMinidump::CreateInstance);
 109   });
 110 }
 111
 112 void ProcessMinidump::Terminate() {
 113   PluginManager::UnregisterPlugin(ProcessMinidump::CreateInstance);
 114 }
 115
 116 Status ProcessMinidump::DoLoadCore() {
 117   Status error;
 118
 119   m_thread_list = m_minidump_parser.GetThreads();
 120   m_active_exception = m_minidump_parser.GetExceptionStream();
 121   ReadModuleList();
 122   GetTarget().SetArchitecture(GetArchitecture());
 123
 124   llvm::Optional<lldb::pid_t> pid = m_minidump_parser.GetPid();
 125   if (!pid) {
 126     error.SetErrorString("failed to parse PID");
 127     return error;
 128   }
 129   SetID(pid.getValue());
 130
 131   return error;
 132 }
 133
 134 DynamicLoader *ProcessMinidump::GetDynamicLoader() {
 135   if (m_dyld_ap.get() == nullptr)
 136     m_dyld_ap.reset(DynamicLoader::FindPlugin(this, nullptr));
 137   return m_dyld_ap.get();
 138 }
 139
 140 ConstString ProcessMinidump::GetPluginName() { return GetPluginNameStatic(); }
 141
 142 uint32_t ProcessMinidump::GetPluginVersion() { return 1; }
 143
 144 Status ProcessMinidump::DoDestroy() { return Status(); }
 145
 146 void ProcessMinidump::RefreshStateAfterStop() {
 147   if (!m_active_exception)
 148     return;
 149
 150   if (m_active_exception->exception_record.exception_code ==
 151       MinidumpException::DumpRequested) {
 152     return;
 153   }
 154
 155   lldb::StopInfoSP stop_info;
 156   lldb::ThreadSP stop_thread;
 157
 158   Process::m_thread_list.SetSelectedThreadByID(m_active_exception->thread_id);
 159   stop_thread = Process::m_thread_list.GetSelectedThread();
 160   ArchSpec arch = GetArchitecture();
 161
 162   if (arch.GetTriple().getOS() == llvm::Triple::Linux) {
 163     stop_info = StopInfo::CreateStopReasonWithSignal(
 164         *stop_thread, m_active_exception->exception_record.exception_code);
 165   } else {
 166     std::string desc;
 167     llvm::raw_string_ostream desc_stream(desc);
 168     desc_stream << "Exception "
 169                 << llvm::format_hex(
 170                        m_active_exception->exception_record.exception_code, 8)
 171                 << " encountered at address "
 172                 << llvm::format_hex(
 173                        m_active_exception->exception_record.exception_address,
 174                        8);
 175     stop_info = StopInfo::CreateStopReasonWithException(
 176         *stop_thread, desc_stream.str().c_str());
 177   }
 178
 179   stop_thread->SetStopInfo(stop_info);
 180 }
 181
 182 bool ProcessMinidump::IsAlive() { return true; }
 183
 184 bool ProcessMinidump::WarnBeforeDetach() const { return false; }
 185
 186 size_t ProcessMinidump::ReadMemory(lldb::addr_t addr, void *buf, size_t size,
 187                                    Status &error) {
 188   // Don't allow the caching that lldb_private::Process::ReadMemory does
 189   // since we have it all cached in our dump file anyway.
 190   return DoReadMemory(addr, buf, size, error);
 191 }
 192
 193 size_t ProcessMinidump::DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
 194                                      Status &error) {
 195
 196   llvm::ArrayRef<uint8_t> mem = m_minidump_parser.GetMemory(addr, size);
 197   if (mem.empty()) {
 198     error.SetErrorString("could not parse memory info");
 199     return 0;
 200   }
 201
 202   std::memcpy(buf, mem.data(), mem.size());
 203   return mem.size();
 204 }
 205
 206 ArchSpec ProcessMinidump::GetArchitecture() {
 207   if (!m_is_wow64) {
 208     return m_minidump_parser.GetArchitecture();
 209   }
 210
 211   llvm::Triple triple;
 212   triple.setVendor(llvm::Triple::VendorType::UnknownVendor);
 213   triple.setArch(llvm::Triple::ArchType::x86);
 214   triple.setOS(llvm::Triple::OSType::Win32);
 215   return ArchSpec(triple);
 216 }
 217
 218 Status ProcessMinidump::GetMemoryRegionInfo(lldb::addr_t load_addr,
 219                                             MemoryRegionInfo &range_info) {
 220   Status error;
 221   auto info = m_minidump_parser.GetMemoryRegionInfo(load_addr);
 222   if (!info) {
 223     error.SetErrorString("No valid MemoryRegionInfo found!");
 224     return error;
 225   }
 226   range_info = info.getValue();
 227   return error;
 228 }
 229
 230 void ProcessMinidump::Clear() { Process::m_thread_list.Clear(); }
 231
 232 bool ProcessMinidump::UpdateThreadList(ThreadList &old_thread_list,
 233                                        ThreadList &new_thread_list) {
 234   uint32_t num_threads = 0;
 235   if (m_thread_list.size() > 0)
 236     num_threads = m_thread_list.size();
 237
 238   for (lldb::tid_t tid = 0; tid < num_threads; ++tid) {
 239     llvm::ArrayRef<uint8_t> context;
 240     if (!m_is_wow64)
 241       context = m_minidump_parser.GetThreadContext(m_thread_list[tid]);
 242     else
 243       context = m_minidump_parser.GetThreadContextWow64(m_thread_list[tid]);
 244
 245     lldb::ThreadSP thread_sp(
 246         new ThreadMinidump(*this, m_thread_list[tid], context));
 247     new_thread_list.AddThread(thread_sp);
 248   }
 249   return new_thread_list.GetSize(false) > 0;
 250 }
 251
 252 void ProcessMinidump::ReadModuleList() {
 253   std::vector<const MinidumpModule *> filtered_modules =
 254       m_minidump_parser.GetFilteredModuleList();
 255
 256   for (auto module : filtered_modules) {
 257     llvm::Optional<std::string> name =
 258         m_minidump_parser.GetMinidumpString(module->module_name_rva);
 259
 260     if (!name)
 261       continue;
 262
 263     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_MODULES));
 264     if (log) {
 265       log->Printf("ProcessMinidump::%s found module: name: %s %#010" PRIx64
 266                   "-%#010" PRIx64 " size: %" PRIu32,
 267                   __FUNCTION__, name.getValue().c_str(),
 268                   uint64_t(module->base_of_image),
 269                   module->base_of_image + module->size_of_image,
 270                   uint32_t(module->size_of_image));
 271     }
 272
 273     // check if the process is wow64 - a 32 bit windows process running on a
 274     // 64 bit windows
 275     if (llvm::StringRef(name.getValue()).endswith_lower("wow64.dll")) {
 276       m_is_wow64 = true;
 277     }
 278
 279     const auto file_spec = FileSpec(name.getValue(), true);
 280     ModuleSpec module_spec = file_spec;
 281     Status error;
 282     lldb::ModuleSP module_sp = GetTarget().GetSharedModule(module_spec, &error);
 283     if (!module_sp || error.Fail()) {
 284       continue;
 285     }
 286
 287     if (log) {
 288       log->Printf("ProcessMinidump::%s load module: name: %s", __FUNCTION__,
 289                   name.getValue().c_str());
 290     }
 291
 292     bool load_addr_changed = false;
 293     module_sp->SetLoadAddress(GetTarget(), module->base_of_image, false,
 294                               load_addr_changed);
 295   }
 296 }
 297
 298 bool ProcessMinidump::GetProcessInfo(ProcessInstanceInfo &info) {
 299   info.Clear();
 300   info.SetProcessID(GetID());
 301   info.SetArchitecture(GetArchitecture());
 302   lldb::ModuleSP module_sp = GetTarget().GetExecutableModule();
 303   if (module_sp) {
 304     const bool add_exe_file_as_first_arg = false;
 305     info.SetExecutableFile(GetTarget().GetExecutableModule()->GetFileSpec(),
 306                            add_exe_file_as_first_arg);
 307   }
 308   return true;
 309 }