ProcessElfCore.cpp revision 263367
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 { 136 last_entry->SetRangeEnd (range_entry.GetRangeEnd()); 137 last_entry->data.SetRangeEnd (range_entry.data.GetRangeEnd()); 138 } 139 else 140 { 141 m_core_aranges.Append(range_entry); 142 } 143 144 return addr; 145} 146 147//---------------------------------------------------------------------- 148// Process Control 149//---------------------------------------------------------------------- 150Error 151ProcessElfCore::DoLoadCore () 152{ 153 Error error; 154 if (!m_core_module_sp) 155 { 156 error.SetErrorString ("invalid core module"); 157 return error; 158 } 159 160 ObjectFileELF *core = (ObjectFileELF *)(m_core_module_sp->GetObjectFile()); 161 if (core == NULL) 162 { 163 error.SetErrorString ("invalid core object file"); 164 return error; 165 } 166 167 const uint32_t num_segments = core->GetProgramHeaderCount(); 168 if (num_segments == 0) 169 { 170 error.SetErrorString ("core file has no sections"); 171 return error; 172 } 173 174 SetCanJIT(false); 175 176 m_thread_data_valid = true; 177 178 bool ranges_are_sorted = true; 179 lldb::addr_t vm_addr = 0; 180 /// Walk through segments and Thread and Address Map information. 181 /// PT_NOTE - Contains Thread and Register information 182 /// PT_LOAD - Contains a contiguous range of Process Address Space 183 for(uint32_t i = 1; i <= num_segments; i++) 184 { 185 const elf::ELFProgramHeader *header = core->GetProgramHeaderByIndex(i); 186 assert(header != NULL); 187 188 DataExtractor data = core->GetSegmentDataByIndex(i); 189 190 // Parse thread contexts and auxv structure 191 if (header->p_type == llvm::ELF::PT_NOTE) 192 ParseThreadContextsFromNoteSegment(header, data); 193 194 // PT_LOAD segments contains address map 195 if (header->p_type == llvm::ELF::PT_LOAD) 196 { 197 lldb::addr_t last_addr = AddAddressRangeFromLoadSegment(header); 198 if (vm_addr > last_addr) 199 ranges_are_sorted = false; 200 vm_addr = last_addr; 201 } 202 } 203 204 if (!ranges_are_sorted) 205 m_core_aranges.Sort(); 206 207 // Even if the architecture is set in the target, we need to override 208 // it to match the core file which is always single arch. 209 ArchSpec arch (m_core_module_sp->GetArchitecture()); 210 if (arch.IsValid()) 211 m_target.SetArchitecture(arch); 212 213 return error; 214} 215 216lldb_private::DynamicLoader * 217ProcessElfCore::GetDynamicLoader () 218{ 219 if (m_dyld_ap.get() == NULL) 220 m_dyld_ap.reset (DynamicLoader::FindPlugin(this, DynamicLoaderPOSIXDYLD::GetPluginNameStatic().GetCString())); 221 return m_dyld_ap.get(); 222} 223 224bool 225ProcessElfCore::UpdateThreadList (ThreadList &old_thread_list, ThreadList &new_thread_list) 226{ 227 const uint32_t num_threads = GetNumThreadContexts (); 228 if (!m_thread_data_valid) 229 return false; 230 231 for (lldb::tid_t tid = 0; tid < num_threads; ++tid) 232 { 233 const ThreadData &td = m_thread_data[tid]; 234 lldb::ThreadSP thread_sp(new ThreadElfCore (*this, tid, td)); 235 new_thread_list.AddThread (thread_sp); 236 } 237 return new_thread_list.GetSize(false) > 0; 238} 239 240void 241ProcessElfCore::RefreshStateAfterStop () 242{ 243} 244 245Error 246ProcessElfCore::DoDestroy () 247{ 248 return Error(); 249} 250 251//------------------------------------------------------------------ 252// Process Queries 253//------------------------------------------------------------------ 254 255bool 256ProcessElfCore::IsAlive () 257{ 258 return true; 259} 260 261//------------------------------------------------------------------ 262// Process Memory 263//------------------------------------------------------------------ 264size_t 265ProcessElfCore::ReadMemory (lldb::addr_t addr, void *buf, size_t size, Error &error) 266{ 267 // Don't allow the caching that lldb_private::Process::ReadMemory does 268 // since in core files we have it all cached our our core file anyway. 269 return DoReadMemory (addr, buf, size, error); 270} 271 272size_t 273ProcessElfCore::DoReadMemory (lldb::addr_t addr, void *buf, size_t size, Error &error) 274{ 275 ObjectFile *core_objfile = m_core_module_sp->GetObjectFile(); 276 277 if (core_objfile == NULL) 278 return 0; 279 280 // Get the address range 281 const VMRangeToFileOffset::Entry *address_range = m_core_aranges.FindEntryThatContains (addr); 282 if (address_range == NULL || address_range->GetRangeEnd() < addr) 283 { 284 error.SetErrorStringWithFormat ("core file does not contain 0x%" PRIx64, addr); 285 return 0; 286 } 287 288 // Convert the address into core file offset 289 const lldb::addr_t offset = addr - address_range->GetRangeBase(); 290 const lldb::addr_t file_start = address_range->data.GetRangeBase(); 291 const lldb::addr_t file_end = address_range->data.GetRangeEnd(); 292 size_t bytes_to_read = size; // Number of bytes to read from the core file 293 size_t bytes_copied = 0; // Number of bytes actually read from the core file 294 size_t zero_fill_size = 0; // Padding 295 lldb::addr_t bytes_left = 0; // Number of bytes available in the core file from the given address 296 297 if (file_end > offset) 298 bytes_left = file_end - offset; 299 300 if (bytes_to_read > bytes_left) 301 { 302 zero_fill_size = bytes_to_read - bytes_left; 303 bytes_to_read = bytes_left; 304 } 305 306 // If there is data available on the core file read it 307 if (bytes_to_read) 308 bytes_copied = core_objfile->CopyData(offset + file_start, bytes_to_read, buf); 309 310 assert(zero_fill_size <= size); 311 // Pad remaining bytes 312 if (zero_fill_size) 313 memset(((char *)buf) + bytes_copied, 0, zero_fill_size); 314 315 return bytes_copied + zero_fill_size; 316} 317 318void 319ProcessElfCore::Clear() 320{ 321 m_thread_list.Clear(); 322} 323 324void 325ProcessElfCore::Initialize() 326{ 327 static bool g_initialized = false; 328 329 if (g_initialized == false) 330 { 331 g_initialized = true; 332 PluginManager::RegisterPlugin (GetPluginNameStatic(), GetPluginDescriptionStatic(), CreateInstance); 333 } 334} 335 336lldb::addr_t 337ProcessElfCore::GetImageInfoAddress() 338{ 339 Target *target = &GetTarget(); 340 ObjectFile *obj_file = target->GetExecutableModule()->GetObjectFile(); 341 Address addr = obj_file->GetImageInfoAddress(target); 342 343 if (addr.IsValid()) 344 return addr.GetLoadAddress(target); 345 return LLDB_INVALID_ADDRESS; 346} 347 348/// Core files PT_NOTE segment descriptor types 349enum { 350 NT_PRSTATUS = 1, 351 NT_FPREGSET, 352 NT_PRPSINFO, 353 NT_TASKSTRUCT, 354 NT_PLATFORM, 355 NT_AUXV 356}; 357 358enum { 359 NT_FREEBSD_PRSTATUS = 1, 360 NT_FREEBSD_FPREGSET, 361 NT_FREEBSD_PRPSINFO, 362 NT_FREEBSD_THRMISC = 7, 363 NT_FREEBSD_PROCSTAT_AUXV = 16 364}; 365 366// Parse a FreeBSD NT_PRSTATUS note - see FreeBSD sys/procfs.h for details. 367static void 368ParseFreeBSDPrStatus(ThreadData *thread_data, DataExtractor &data, 369 ArchSpec &arch) 370{ 371 lldb::offset_t offset = 0; 372 bool have_padding = (arch.GetMachine() == llvm::Triple::mips64 || 373 arch.GetMachine() == llvm::Triple::x86_64); 374 int pr_version = data.GetU32(&offset); 375 376 Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_PROCESS)); 377 if (log) 378 { 379 if (pr_version > 1) 380 log->Printf("FreeBSD PRSTATUS unexpected version %d", pr_version); 381 } 382 383 if (have_padding) 384 offset += 4; 385 offset += 28; // pr_statussz, pr_gregsetsz, pr_fpregsetsz, pr_osreldate 386 thread_data->signo = data.GetU32(&offset); // pr_cursig 387 offset += 4; // pr_pid 388 if (have_padding) 389 offset += 4; 390 391 size_t len = data.GetByteSize() - offset; 392 thread_data->gpregset = DataExtractor(data, offset, len); 393} 394 395static void 396ParseFreeBSDThrMisc(ThreadData *thread_data, DataExtractor &data) 397{ 398 lldb::offset_t offset = 0; 399 thread_data->name = data.GetCStr(&offset, 20); 400} 401 402/// Parse Thread context from PT_NOTE segment and store it in the thread list 403/// Notes: 404/// 1) A PT_NOTE segment is composed of one or more NOTE entries. 405/// 2) NOTE Entry contains a standard header followed by variable size data. 406/// (see ELFNote structure) 407/// 3) A Thread Context in a core file usually described by 3 NOTE entries. 408/// a) NT_PRSTATUS - Register context 409/// b) NT_PRPSINFO - Process info(pid..) 410/// c) NT_FPREGSET - Floating point registers 411/// 4) The NOTE entries can be in any order 412/// 5) If a core file contains multiple thread contexts then there is two data forms 413/// a) Each thread context(2 or more NOTE entries) contained in its own segment (PT_NOTE) 414/// b) All thread context is stored in a single segment(PT_NOTE). 415/// This case is little tricker since while parsing we have to find where the 416/// new thread starts. The current implementation marks beginning of 417/// new thread when it finds NT_PRSTATUS or NT_PRPSINFO NOTE entry. 418/// For case (b) there may be either one NT_PRPSINFO per thread, or a single 419/// one that applies to all threads (depending on the platform type). 420void 421ProcessElfCore::ParseThreadContextsFromNoteSegment(const elf::ELFProgramHeader *segment_header, 422 DataExtractor segment_data) 423{ 424 assert(segment_header && segment_header->p_type == llvm::ELF::PT_NOTE); 425 426 lldb::offset_t offset = 0; 427 ThreadData *thread_data = new ThreadData(); 428 bool have_prstatus = false; 429 bool have_prpsinfo = false; 430 431 ArchSpec arch = GetArchitecture(); 432 ELFLinuxPrPsInfo prpsinfo; 433 ELFLinuxPrStatus prstatus; 434 size_t header_size; 435 size_t len; 436 437 // Loop through the NOTE entires in the segment 438 while (offset < segment_header->p_filesz) 439 { 440 ELFNote note = ELFNote(); 441 note.Parse(segment_data, &offset); 442 443 // Beginning of new thread 444 if ((note.n_type == NT_PRSTATUS && have_prstatus) || 445 (note.n_type == NT_PRPSINFO && have_prpsinfo)) 446 { 447 assert(thread_data->gpregset.GetByteSize() > 0); 448 // Add the new thread to thread list 449 m_thread_data.push_back(*thread_data); 450 thread_data = new ThreadData(); 451 have_prstatus = false; 452 have_prpsinfo = false; 453 } 454 455 size_t note_start, note_size; 456 note_start = offset; 457 note_size = llvm::RoundUpToAlignment(note.n_descsz, 4); 458 459 // Store the NOTE information in the current thread 460 DataExtractor note_data (segment_data, note_start, note_size); 461 if (note.n_name == "FreeBSD") 462 { 463 switch (note.n_type) 464 { 465 case NT_FREEBSD_PRSTATUS: 466 have_prstatus = true; 467 ParseFreeBSDPrStatus(thread_data, note_data, arch); 468 break; 469 case NT_FREEBSD_FPREGSET: 470 thread_data->fpregset = note_data; 471 break; 472 case NT_FREEBSD_PRPSINFO: 473 have_prpsinfo = true; 474 break; 475 case NT_FREEBSD_THRMISC: 476 ParseFreeBSDThrMisc(thread_data, note_data); 477 break; 478 case NT_FREEBSD_PROCSTAT_AUXV: 479 // FIXME: FreeBSD sticks an int at the beginning of the note 480 m_auxv = DataExtractor(segment_data, note_start + 4, note_size - 4); 481 break; 482 default: 483 break; 484 } 485 } 486 else 487 { 488 switch (note.n_type) 489 { 490 case NT_PRSTATUS: 491 have_prstatus = true; 492 prstatus.Parse(note_data, arch); 493 thread_data->signo = prstatus.pr_cursig; 494 header_size = ELFLinuxPrStatus::GetSize(arch); 495 len = note_data.GetByteSize() - header_size; 496 thread_data->gpregset = DataExtractor(note_data, header_size, len); 497 break; 498 case NT_FPREGSET: 499 thread_data->fpregset = note_data; 500 break; 501 case NT_PRPSINFO: 502 have_prpsinfo = true; 503 prpsinfo.Parse(note_data, arch); 504 thread_data->name = prpsinfo.pr_fname; 505 break; 506 case NT_AUXV: 507 m_auxv = DataExtractor(note_data); 508 break; 509 default: 510 break; 511 } 512 } 513 514 offset += note_size; 515 } 516 // Add last entry in the note section 517 if (thread_data && thread_data->gpregset.GetByteSize() > 0) 518 { 519 m_thread_data.push_back(*thread_data); 520 } 521} 522 523uint32_t 524ProcessElfCore::GetNumThreadContexts () 525{ 526 if (!m_thread_data_valid) 527 DoLoadCore(); 528 return m_thread_data.size(); 529} 530 531ArchSpec 532ProcessElfCore::GetArchitecture() 533{ 534 ObjectFileELF *core_file = (ObjectFileELF *)(m_core_module_sp->GetObjectFile()); 535 ArchSpec arch; 536 core_file->GetArchitecture(arch); 537 return arch; 538} 539 540const lldb::DataBufferSP 541ProcessElfCore::GetAuxvData() 542{ 543 const uint8_t *start = m_auxv.GetDataStart(); 544 size_t len = m_auxv.GetByteSize(); 545 lldb::DataBufferSP buffer(new lldb_private::DataBufferHeap(start, len)); 546 return buffer; 547} 548 549