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