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 segments");
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 namespace FREEBSD {
409 
410 enum {
411     NT_PRSTATUS      = 1,
412     NT_FPREGSET,
413     NT_PRPSINFO,
414     NT_THRMISC       = 7,
415     NT_PROCSTAT_AUXV = 16,
416     NT_PPC_VMX       = 0x100
417 };
418 
419 }
420 
421 // Parse a FreeBSD NT_PRSTATUS note - see FreeBSD sys/procfs.h for details.
422 static void
423 ParseFreeBSDPrStatus(ThreadData &thread_data, DataExtractor &data,
424                      ArchSpec &arch)
425 {
426     lldb::offset_t offset = 0;
427     bool lp64 = (arch.GetMachine() == llvm::Triple::aarch64 ||
428                  arch.GetMachine() == llvm::Triple::mips64 ||
429                  arch.GetMachine() == llvm::Triple::ppc64 ||
430                  arch.GetMachine() == llvm::Triple::x86_64);
431     int pr_version = data.GetU32(&offset);
432 
433     Log *log (GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
434     if (log)
435     {
436         if (pr_version > 1)
437             log->Printf("FreeBSD PRSTATUS unexpected version %d", pr_version);
438     }
439 
440     // Skip padding, pr_statussz, pr_gregsetsz, pr_fpregsetsz, pr_osreldate
441     if (lp64)
442         offset += 32;
443     else
444         offset += 16;
445 
446     thread_data.signo = data.GetU32(&offset); // pr_cursig
447     offset += 4;        // pr_pid
448     if (lp64)
449         offset += 4;
450 
451     size_t len = data.GetByteSize() - offset;
452     thread_data.gpregset = DataExtractor(data, offset, len);
453 }
454 
455 static void
456 ParseFreeBSDThrMisc(ThreadData &thread_data, DataExtractor &data)
457 {
458     lldb::offset_t offset = 0;
459     thread_data.name = data.GetCStr(&offset, 20);
460 }
461 
462 /// Parse Thread context from PT_NOTE segment and store it in the thread list
463 /// Notes:
464 /// 1) A PT_NOTE segment is composed of one or more NOTE entries.
465 /// 2) NOTE Entry contains a standard header followed by variable size data.
466 ///   (see ELFNote structure)
467 /// 3) A Thread Context in a core file usually described by 3 NOTE entries.
468 ///    a) NT_PRSTATUS - Register context
469 ///    b) NT_PRPSINFO - Process info(pid..)
470 ///    c) NT_FPREGSET - Floating point registers
471 /// 4) The NOTE entries can be in any order
472 /// 5) If a core file contains multiple thread contexts then there is two data forms
473 ///    a) Each thread context(2 or more NOTE entries) contained in its own segment (PT_NOTE)
474 ///    b) All thread context is stored in a single segment(PT_NOTE).
475 ///        This case is little tricker since while parsing we have to find where the
476 ///        new thread starts. The current implementation marks beginning of
477 ///        new thread when it finds NT_PRSTATUS or NT_PRPSINFO NOTE entry.
478 ///    For case (b) there may be either one NT_PRPSINFO per thread, or a single
479 ///    one that applies to all threads (depending on the platform type).
480 void
481 ProcessElfCore::ParseThreadContextsFromNoteSegment(const elf::ELFProgramHeader *segment_header,
482                                                    DataExtractor segment_data)
483 {
484     assert(segment_header && segment_header->p_type == llvm::ELF::PT_NOTE);
485 
486     lldb::offset_t offset = 0;
487     std::unique_ptr<ThreadData> thread_data(new ThreadData);
488     bool have_prstatus = false;
489     bool have_prpsinfo = false;
490 
491     ArchSpec arch = GetArchitecture();
492     ELFLinuxPrPsInfo prpsinfo;
493     ELFLinuxPrStatus prstatus;
494     size_t header_size;
495     size_t len;
496 
497     // Loop through the NOTE entires in the segment
498     while (offset < segment_header->p_filesz)
499     {
500         ELFNote note = ELFNote();
501         note.Parse(segment_data, &offset);
502 
503         // Beginning of new thread
504         if ((note.n_type == NT_PRSTATUS && have_prstatus) ||
505             (note.n_type == NT_PRPSINFO && have_prpsinfo))
506         {
507             assert(thread_data->gpregset.GetByteSize() > 0);
508             // Add the new thread to thread list
509             m_thread_data.push_back(*thread_data);
510             *thread_data = ThreadData();
511             have_prstatus = false;
512             have_prpsinfo = false;
513         }
514 
515         size_t note_start, note_size;
516         note_start = offset;
517         note_size = llvm::RoundUpToAlignment(note.n_descsz, 4);
518 
519         // Store the NOTE information in the current thread
520         DataExtractor note_data (segment_data, note_start, note_size);
521         if (note.n_name == "FreeBSD")
522         {
523             m_os = llvm::Triple::FreeBSD;
524             switch (note.n_type)
525             {
526                 case FREEBSD::NT_PRSTATUS:
527                     have_prstatus = true;
528                     ParseFreeBSDPrStatus(*thread_data, note_data, arch);
529                     break;
530                 case FREEBSD::NT_FPREGSET:
531                     thread_data->fpregset = note_data;
532                     break;
533                 case FREEBSD::NT_PRPSINFO:
534                     have_prpsinfo = true;
535                     break;
536                 case FREEBSD::NT_THRMISC:
537                     ParseFreeBSDThrMisc(*thread_data, note_data);
538                     break;
539                 case FREEBSD::NT_PROCSTAT_AUXV:
540                     // FIXME: FreeBSD sticks an int at the beginning of the note
541                     m_auxv = DataExtractor(segment_data, note_start + 4, note_size - 4);
542                     break;
543                 case FREEBSD::NT_PPC_VMX:
544                     thread_data->vregset = note_data;
545                     break;
546                 default:
547                     break;
548             }
549         }
550         else
551         {
552             switch (note.n_type)
553             {
554                 case NT_PRSTATUS:
555                     have_prstatus = true;
556                     prstatus.Parse(note_data, arch);
557                     thread_data->signo = prstatus.pr_cursig;
558                     header_size = ELFLinuxPrStatus::GetSize(arch);
559                     len = note_data.GetByteSize() - header_size;
560                     thread_data->gpregset = DataExtractor(note_data, header_size, len);
561                     break;
562                 case NT_FPREGSET:
563                     thread_data->fpregset = note_data;
564                     break;
565                 case NT_PRPSINFO:
566                     have_prpsinfo = true;
567                     prpsinfo.Parse(note_data, arch);
568                     thread_data->name = prpsinfo.pr_fname;
569                     break;
570                 case NT_AUXV:
571                     m_auxv = DataExtractor(note_data);
572                     break;
573                 default:
574                     break;
575             }
576         }
577 
578         offset += note_size;
579     }
580     // Add last entry in the note section
581     if (thread_data && thread_data->gpregset.GetByteSize() > 0)
582     {
583         m_thread_data.push_back(*thread_data);
584     }
585 }
586 
587 uint32_t
588 ProcessElfCore::GetNumThreadContexts ()
589 {
590     if (!m_thread_data_valid)
591         DoLoadCore();
592     return m_thread_data.size();
593 }
594 
595 ArchSpec
596 ProcessElfCore::GetArchitecture()
597 {
598     ObjectFileELF *core_file = (ObjectFileELF *)(m_core_module_sp->GetObjectFile());
599     ArchSpec arch;
600     core_file->GetArchitecture(arch);
601     return arch;
602 }
603 
604 const lldb::DataBufferSP
605 ProcessElfCore::GetAuxvData()
606 {
607     const uint8_t *start = m_auxv.GetDataStart();
608     size_t len = m_auxv.GetByteSize();
609     lldb::DataBufferSP buffer(new lldb_private::DataBufferHeap(start, len));
610     return buffer;
611 }
612