contrib/llvm/tools/lldb/source/Plugins/Process/elf-core/ProcessElfCore.cpp

   1 //===-- ProcessElfCore.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 // C Includes
  11 #include <stdlib.h>
  12
  13 // Other libraries and framework includes
  14 #include "lldb/Core/PluginManager.h"
  15 #include "lldb/Core/Module.h"
  16 #include "lldb/Core/ModuleSpec.h"
  17 #include "lldb/Core/Section.h"
  18 #include "lldb/Core/State.h"
  19 #include "lldb/Core/DataBufferHeap.h"
  20 #include "lldb/Core/Log.h"
  21 #include "lldb/Target/Target.h"
  22 #include "lldb/Target/DynamicLoader.h"
  23 #include "lldb/Target/UnixSignals.h"
  24
  25 #include "llvm/Support/ELF.h"
  26
  27 #include "Plugins/ObjectFile/ELF/ObjectFileELF.h"
  28 #include "Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.h"
  29 #include "Plugins/Process/Utility/FreeBSDSignals.h"
  30 #include "Plugins/Process/Utility/LinuxSignals.h"
  31
  32 // Project includes
  33 #include "ProcessElfCore.h"
  34 #include "ThreadElfCore.h"
  35
  36 using namespace lldb_private;
  37
  38 ConstString
  39 ProcessElfCore::GetPluginNameStatic()
  40 {
  41     static ConstString g_name("elf-core");
  42     return g_name;
  43 }
  44
  45 const char *
  46 ProcessElfCore::GetPluginDescriptionStatic()
  47 {
  48     return "ELF core dump plug-in.";
  49 }
  50
  51 void
  52 ProcessElfCore::Terminate()
  53 {
  54     PluginManager::UnregisterPlugin (ProcessElfCore::CreateInstance);
  55 }
  56
  57
  58 lldb::ProcessSP
  59 ProcessElfCore::CreateInstance (Target &target, Listener &listener, const FileSpec *crash_file)
  60 {
  61     lldb::ProcessSP process_sp;
  62     if (crash_file)
  63     {
  64         // Read enough data for a ELF32 header or ELF64 header
  65         const size_t header_size = sizeof(llvm::ELF::Elf64_Ehdr);
  66
  67         lldb::DataBufferSP data_sp (crash_file->ReadFileContents(0, header_size));
  68         if (data_sp && data_sp->GetByteSize() == header_size &&
  69             elf::ELFHeader::MagicBytesMatch (data_sp->GetBytes()))
  70         {
  71             elf::ELFHeader elf_header;
  72             DataExtractor data(data_sp, lldb::eByteOrderLittle, 4);
  73             lldb::offset_t data_offset = 0;
  74             if (elf_header.Parse(data, &data_offset))
  75             {
  76                 if (elf_header.e_type == llvm::ELF::ET_CORE)
  77                     process_sp.reset(new ProcessElfCore (target, listener, *crash_file));
  78             }
  79         }
  80     }
  81     return process_sp;
  82 }
  83
  84 bool
  85 ProcessElfCore::CanDebug(Target &target, bool plugin_specified_by_name)
  86 {
  87     // For now we are just making sure the file exists for a given module
  88     if (!m_core_module_sp && m_core_file.Exists())
  89     {
  90         ModuleSpec core_module_spec(m_core_file, target.GetArchitecture());
  91         Error error (ModuleList::GetSharedModule (core_module_spec, m_core_module_sp,
  92                                                   NULL, NULL, NULL));
  93         if (m_core_module_sp)
  94         {
  95             ObjectFile *core_objfile = m_core_module_sp->GetObjectFile();
  96             if (core_objfile && core_objfile->GetType() == ObjectFile::eTypeCoreFile)
  97                 return true;
  98         }
  99     }
 100     return false;
 101 }
 102
 103 //----------------------------------------------------------------------
 104 // ProcessElfCore constructor
 105 //----------------------------------------------------------------------
 106 ProcessElfCore::ProcessElfCore(Target& target, Listener &listener,
 107                                const FileSpec &core_file) :
 108     Process (target, listener),
 109     m_core_module_sp (),
 110     m_core_file (core_file),
 111     m_dyld_plugin_name (),
 112     m_os(llvm::Triple::UnknownOS),
 113     m_thread_data_valid(false),
 114     m_thread_data(),
 115     m_core_aranges ()
 116 {
 117 }
 118
 119 //----------------------------------------------------------------------
 120 // Destructor
 121 //----------------------------------------------------------------------
 122 ProcessElfCore::~ProcessElfCore()
 123 {
 124     Clear();
 125     // We need to call finalize on the process before destroying ourselves
 126     // to make sure all of the broadcaster cleanup goes as planned. If we
 127     // destruct this class, then Process::~Process() might have problems
 128     // trying to fully destroy the broadcaster.
 129     Finalize();
 130 }
 131
 132 //----------------------------------------------------------------------
 133 // PluginInterface
 134 //----------------------------------------------------------------------
 135 ConstString
 136 ProcessElfCore::GetPluginName()
 137 {
 138     return GetPluginNameStatic();
 139 }
 140
 141 uint32_t
 142 ProcessElfCore::GetPluginVersion()
 143 {
 144     return 1;
 145 }
 146
 147 lldb::addr_t
 148 ProcessElfCore::AddAddressRangeFromLoadSegment(const elf::ELFProgramHeader *header)
 149 {
 150     lldb::addr_t addr = header->p_vaddr;
 151     FileRange file_range (header->p_offset, header->p_filesz);
 152     VMRangeToFileOffset::Entry range_entry(addr, header->p_memsz, file_range);
 153
 154     VMRangeToFileOffset::Entry *last_entry = m_core_aranges.Back();
 155     if (last_entry &&
 156         last_entry->GetRangeEnd() == range_entry.GetRangeBase() &&
 157         last_entry->data.GetRangeEnd() == range_entry.data.GetRangeBase() &&
 158         last_entry->GetByteSize() == last_entry->data.GetByteSize())
 159     {
 160         last_entry->SetRangeEnd (range_entry.GetRangeEnd());
 161         last_entry->data.SetRangeEnd (range_entry.data.GetRangeEnd());
 162     }
 163     else
 164     {
 165         m_core_aranges.Append(range_entry);
 166     }
 167
 168     return addr;
 169 }
 170
 171 //----------------------------------------------------------------------
 172 // Process Control
 173 //----------------------------------------------------------------------
 174 Error
 175 ProcessElfCore::DoLoadCore ()
 176 {
 177     Error error;
 178     if (!m_core_module_sp)
 179     {
 180         error.SetErrorString ("invalid core module");
 181         return error;
 182     }
 183
 184     ObjectFileELF *core = (ObjectFileELF *)(m_core_module_sp->GetObjectFile());
 185     if (core == NULL)
 186     {
 187         error.SetErrorString ("invalid core object file");
 188         return error;
 189     }
 190
 191     const uint32_t num_segments = core->GetProgramHeaderCount();
 192     if (num_segments == 0)
 193     {
 194         error.SetErrorString ("core file has no sections");
 195         return error;
 196     }
 197
 198     SetCanJIT(false);
 199
 200     m_thread_data_valid = true;
 201
 202     bool ranges_are_sorted = true;
 203     lldb::addr_t vm_addr = 0;
 204     /// Walk through segments and Thread and Address Map information.
 205     /// PT_NOTE - Contains Thread and Register information
 206     /// PT_LOAD - Contains a contiguous range of Process Address Space
 207     for(uint32_t i = 1; i <= num_segments; i++)
 208     {
 209         const elf::ELFProgramHeader *header = core->GetProgramHeaderByIndex(i);
 210         assert(header != NULL);
 211
 212         DataExtractor data = core->GetSegmentDataByIndex(i);
 213
 214         // Parse thread contexts and auxv structure
 215         if (header->p_type == llvm::ELF::PT_NOTE)
 216             ParseThreadContextsFromNoteSegment(header, data);
 217
 218         // PT_LOAD segments contains address map
 219         if (header->p_type == llvm::ELF::PT_LOAD)
 220         {
 221             lldb::addr_t last_addr = AddAddressRangeFromLoadSegment(header);
 222             if (vm_addr > last_addr)
 223                 ranges_are_sorted = false;
 224             vm_addr = last_addr;
 225         }
 226     }
 227
 228     if (!ranges_are_sorted)
 229         m_core_aranges.Sort();
 230
 231     // Even if the architecture is set in the target, we need to override
 232     // it to match the core file which is always single arch.
 233     ArchSpec arch (m_core_module_sp->GetArchitecture());
 234     if (arch.IsValid())
 235         m_target.SetArchitecture(arch);
 236
 237     switch (m_os)
 238     {
 239         case llvm::Triple::FreeBSD:
 240         {
 241             static UnixSignalsSP s_freebsd_signals_sp(new FreeBSDSignals ());
 242             SetUnixSignals(s_freebsd_signals_sp);
 243             break;
 244         }
 245         case llvm::Triple::Linux:
 246         {
 247             static UnixSignalsSP s_linux_signals_sp(new process_linux::LinuxSignals ());
 248             SetUnixSignals(s_linux_signals_sp);
 249             break;
 250         }
 251         default:
 252             break;
 253     }
 254
 255     return error;
 256 }
 257
 258 lldb_private::DynamicLoader *
 259 ProcessElfCore::GetDynamicLoader ()
 260 {
 261     if (m_dyld_ap.get() == NULL)
 262         m_dyld_ap.reset (DynamicLoader::FindPlugin(this, DynamicLoaderPOSIXDYLD::GetPluginNameStatic().GetCString()));
 263     return m_dyld_ap.get();
 264 }
 265
 266 bool
 267 ProcessElfCore::UpdateThreadList (ThreadList &old_thread_list, ThreadList &new_thread_list)
 268 {
 269     const uint32_t num_threads = GetNumThreadContexts ();
 270     if (!m_thread_data_valid)
 271         return false;
 272
 273     for (lldb::tid_t tid = 0; tid < num_threads; ++tid)
 274     {
 275         const ThreadData &td = m_thread_data[tid];
 276         lldb::ThreadSP thread_sp(new ThreadElfCore (*this, tid, td));
 277         new_thread_list.AddThread (thread_sp);
 278     }
 279     return new_thread_list.GetSize(false) > 0;
 280 }
 281
 282 void
 283 ProcessElfCore::RefreshStateAfterStop ()
 284 {
 285 }
 286
 287 Error
 288 ProcessElfCore::DoDestroy ()
 289 {
 290     return Error();
 291 }
 292
 293 //------------------------------------------------------------------
 294 // Process Queries
 295 //------------------------------------------------------------------
 296
 297 bool
 298 ProcessElfCore::IsAlive ()
 299 {
 300     return true;
 301 }
 302
 303 //------------------------------------------------------------------
 304 // Process Memory
 305 //------------------------------------------------------------------
 306 size_t
 307 ProcessElfCore::ReadMemory (lldb::addr_t addr, void *buf, size_t size, Error &error)
 308 {
 309     // Don't allow the caching that lldb_private::Process::ReadMemory does
 310     // since in core files we have it all cached our our core file anyway.
 311     return DoReadMemory (addr, buf, size, error);
 312 }
 313
 314 size_t
 315 ProcessElfCore::DoReadMemory (lldb::addr_t addr, void *buf, size_t size, Error &error)
 316 {
 317     ObjectFile *core_objfile = m_core_module_sp->GetObjectFile();
 318
 319     if (core_objfile == NULL)
 320         return 0;
 321
 322     // Get the address range
 323     const VMRangeToFileOffset::Entry *address_range = m_core_aranges.FindEntryThatContains (addr);
 324     if (address_range == NULL || address_range->GetRangeEnd() < addr)
 325     {
 326         error.SetErrorStringWithFormat ("core file does not contain 0x%" PRIx64, addr);
 327         return 0;
 328     }
 329
 330     // Convert the address into core file offset
 331     const lldb::addr_t offset = addr - address_range->GetRangeBase();
 332     const lldb::addr_t file_start = address_range->data.GetRangeBase();
 333     const lldb::addr_t file_end = address_range->data.GetRangeEnd();
 334     size_t bytes_to_read = size; // Number of bytes to read from the core file
 335     size_t bytes_copied = 0;     // Number of bytes actually read from the core file
 336     size_t zero_fill_size = 0;   // Padding
 337     lldb::addr_t bytes_left = 0; // Number of bytes available in the core file from the given address
 338
 339     // Figure out how many on-disk bytes remain in this segment
 340     // starting at the given offset
 341     if (file_end > file_start + offset)
 342         bytes_left = file_end - (file_start + offset);
 343
 344     // Figure out how many bytes we need to zero-fill if we are
 345     // reading more bytes than available in the on-disk segment
 346     if (bytes_to_read > bytes_left)
 347     {
 348         zero_fill_size = bytes_to_read - bytes_left;
 349         bytes_to_read = bytes_left;
 350     }
 351
 352     // If there is data available on the core file read it
 353     if (bytes_to_read)
 354         bytes_copied = core_objfile->CopyData(offset + file_start, bytes_to_read, buf);
 355
 356     assert(zero_fill_size <= size);
 357     // Pad remaining bytes
 358     if (zero_fill_size)
 359         memset(((char *)buf) + bytes_copied, 0, zero_fill_size);
 360
 361     return bytes_copied + zero_fill_size;
 362 }
 363
 364 void
 365 ProcessElfCore::Clear()
 366 {
 367     m_thread_list.Clear();
 368     m_os = llvm::Triple::UnknownOS;
 369
 370     static UnixSignalsSP s_default_unix_signals_sp(new UnixSignals());
 371     SetUnixSignals(s_default_unix_signals_sp);
 372 }
 373
 374 void
 375 ProcessElfCore::Initialize()
 376 {
 377     static bool g_initialized = false;
 378
 379     if (g_initialized == false)
 380     {
 381         g_initialized = true;
 382         PluginManager::RegisterPlugin (GetPluginNameStatic(), GetPluginDescriptionStatic(), CreateInstance);
 383     }
 384 }
 385
 386 lldb::addr_t
 387 ProcessElfCore::GetImageInfoAddress()
 388 {
 389     Target *target = &GetTarget();
 390     ObjectFile *obj_file = target->GetExecutableModule()->GetObjectFile();
 391     Address addr = obj_file->GetImageInfoAddress(target);
 392
 393     if (addr.IsValid())
 394         return addr.GetLoadAddress(target);
 395     return LLDB_INVALID_ADDRESS;
 396 }
 397
 398 /// Core files PT_NOTE segment descriptor types
 399 enum {
 400     NT_PRSTATUS     = 1,
 401     NT_FPREGSET,
 402     NT_PRPSINFO,
 403     NT_TASKSTRUCT,
 404     NT_PLATFORM,
 405     NT_AUXV
 406 };
 407
 408 enum {
 409     NT_FREEBSD_PRSTATUS      = 1,
 410     NT_FREEBSD_FPREGSET,
 411     NT_FREEBSD_PRPSINFO,
 412     NT_FREEBSD_THRMISC       = 7,
 413     NT_FREEBSD_PROCSTAT_AUXV = 16
 414 };
 415
 416 // Parse a FreeBSD NT_PRSTATUS note - see FreeBSD sys/procfs.h for details.
 417 static void
 418 ParseFreeBSDPrStatus(ThreadData &thread_data, DataExtractor &data,
 419                      ArchSpec &arch)
 420 {
 421     lldb::offset_t offset = 0;
 422     bool lp64 = (arch.GetMachine() == llvm::Triple::mips64 ||
 423                  arch.GetMachine() == llvm::Triple::x86_64);
 424     int pr_version = data.GetU32(&offset);
 425
 426     Log *log (GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
 427     if (log)
 428     {
 429         if (pr_version > 1)
 430             log->Printf("FreeBSD PRSTATUS unexpected version %d", pr_version);
 431     }
 432
 433     // Skip padding, pr_statussz, pr_gregsetsz, pr_fpregsetsz, pr_osreldate
 434     if (lp64)
 435         offset += 32;
 436     else
 437         offset += 16;
 438
 439     thread_data.signo = data.GetU32(&offset); // pr_cursig
 440     offset += 4;        // pr_pid
 441     if (lp64)
 442         offset += 4;
 443
 444     size_t len = data.GetByteSize() - offset;
 445     thread_data.gpregset = DataExtractor(data, offset, len);
 446 }
 447
 448 static void
 449 ParseFreeBSDThrMisc(ThreadData &thread_data, DataExtractor &data)
 450 {
 451     lldb::offset_t offset = 0;
 452     thread_data.name = data.GetCStr(&offset, 20);
 453 }
 454
 455 /// Parse Thread context from PT_NOTE segment and store it in the thread list
 456 /// Notes:
 457 /// 1) A PT_NOTE segment is composed of one or more NOTE entries.
 458 /// 2) NOTE Entry contains a standard header followed by variable size data.
 459 ///   (see ELFNote structure)
 460 /// 3) A Thread Context in a core file usually described by 3 NOTE entries.
 461 ///    a) NT_PRSTATUS - Register context
 462 ///    b) NT_PRPSINFO - Process info(pid..)
 463 ///    c) NT_FPREGSET - Floating point registers
 464 /// 4) The NOTE entries can be in any order
 465 /// 5) If a core file contains multiple thread contexts then there is two data forms
 466 ///    a) Each thread context(2 or more NOTE entries) contained in its own segment (PT_NOTE)
 467 ///    b) All thread context is stored in a single segment(PT_NOTE).
 468 ///        This case is little tricker since while parsing we have to find where the
 469 ///        new thread starts. The current implementation marks beginning of
 470 ///        new thread when it finds NT_PRSTATUS or NT_PRPSINFO NOTE entry.
 471 ///    For case (b) there may be either one NT_PRPSINFO per thread, or a single
 472 ///    one that applies to all threads (depending on the platform type).
 473 void
 474 ProcessElfCore::ParseThreadContextsFromNoteSegment(const elf::ELFProgramHeader *segment_header,
 475                                                    DataExtractor segment_data)
 476 {
 477     assert(segment_header && segment_header->p_type == llvm::ELF::PT_NOTE);
 478
 479     lldb::offset_t offset = 0;
 480     std::unique_ptr<ThreadData> thread_data(new ThreadData);
 481     bool have_prstatus = false;
 482     bool have_prpsinfo = false;
 483
 484     ArchSpec arch = GetArchitecture();
 485     ELFLinuxPrPsInfo prpsinfo;
 486     ELFLinuxPrStatus prstatus;
 487     size_t header_size;
 488     size_t len;
 489
 490     // Loop through the NOTE entires in the segment
 491     while (offset < segment_header->p_filesz)
 492     {
 493         ELFNote note = ELFNote();
 494         note.Parse(segment_data, &offset);
 495
 496         // Beginning of new thread
 497         if ((note.n_type == NT_PRSTATUS && have_prstatus) ||
 498             (note.n_type == NT_PRPSINFO && have_prpsinfo))
 499         {
 500             assert(thread_data->gpregset.GetByteSize() > 0);
 501             // Add the new thread to thread list
 502             m_thread_data.push_back(*thread_data);
 503             *thread_data = ThreadData();
 504             have_prstatus = false;
 505             have_prpsinfo = false;
 506         }
 507
 508         size_t note_start, note_size;
 509         note_start = offset;
 510         note_size = llvm::RoundUpToAlignment(note.n_descsz, 4);
 511
 512         // Store the NOTE information in the current thread
 513         DataExtractor note_data (segment_data, note_start, note_size);
 514         if (note.n_name == "FreeBSD")
 515         {
 516             m_os = llvm::Triple::FreeBSD;
 517             switch (note.n_type)
 518             {
 519                 case NT_FREEBSD_PRSTATUS:
 520                     have_prstatus = true;
 521                     ParseFreeBSDPrStatus(*thread_data, note_data, arch);
 522                     break;
 523                 case NT_FREEBSD_FPREGSET:
 524                     thread_data->fpregset = note_data;
 525                     break;
 526                 case NT_FREEBSD_PRPSINFO:
 527                     have_prpsinfo = true;
 528                     break;
 529                 case NT_FREEBSD_THRMISC:
 530                     ParseFreeBSDThrMisc(*thread_data, note_data);
 531                     break;
 532                 case NT_FREEBSD_PROCSTAT_AUXV:
 533                     // FIXME: FreeBSD sticks an int at the beginning of the note
 534                     m_auxv = DataExtractor(segment_data, note_start + 4, note_size - 4);
 535                     break;
 536                 default:
 537                     break;
 538             }
 539         }
 540         else
 541         {
 542             switch (note.n_type)
 543             {
 544                 case NT_PRSTATUS:
 545                     have_prstatus = true;
 546                     prstatus.Parse(note_data, arch);
 547                     thread_data->signo = prstatus.pr_cursig;
 548                     header_size = ELFLinuxPrStatus::GetSize(arch);
 549                     len = note_data.GetByteSize() - header_size;
 550                     thread_data->gpregset = DataExtractor(note_data, header_size, len);
 551                     break;
 552                 case NT_FPREGSET:
 553                     thread_data->fpregset = note_data;
 554                     break;
 555                 case NT_PRPSINFO:
 556                     have_prpsinfo = true;
 557                     prpsinfo.Parse(note_data, arch);
 558                     thread_data->name = prpsinfo.pr_fname;
 559                     break;
 560                 case NT_AUXV:
 561                     m_auxv = DataExtractor(note_data);
 562                     break;
 563                 default:
 564                     break;
 565             }
 566         }
 567
 568         offset += note_size;
 569     }
 570     // Add last entry in the note section
 571     if (thread_data && thread_data->gpregset.GetByteSize() > 0)
 572     {
 573         m_thread_data.push_back(*thread_data);
 574     }
 575 }
 576
 577 uint32_t
 578 ProcessElfCore::GetNumThreadContexts ()
 579 {
 580     if (!m_thread_data_valid)
 581         DoLoadCore();
 582     return m_thread_data.size();
 583 }
 584
 585 ArchSpec
 586 ProcessElfCore::GetArchitecture()
 587 {
 588     ObjectFileELF *core_file = (ObjectFileELF *)(m_core_module_sp->GetObjectFile());
 589     ArchSpec arch;
 590     core_file->GetArchitecture(arch);
 591     return arch;
 592 }
 593
 594 const lldb::DataBufferSP
 595 ProcessElfCore::GetAuxvData()
 596 {
 597     const uint8_t *start = m_auxv.GetDataStart();
 598     size_t len = m_auxv.GetByteSize();
 599     lldb::DataBufferSP buffer(new lldb_private::DataBufferHeap(start, len));
 600     return buffer;
 601 }