1 //===-- ThreadElfCore.cpp -------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "lldb/Target/RegisterContext.h"
10 #include "lldb/Target/StopInfo.h"
11 #include "lldb/Target/Target.h"
12 #include "lldb/Target/Unwind.h"
13 #include "lldb/Utility/DataExtractor.h"
14 #include "lldb/Utility/Log.h"
15 
16 #include "Plugins/Process/Utility/RegisterContextFreeBSD_i386.h"
17 #include "Plugins/Process/Utility/RegisterContextFreeBSD_mips64.h"
18 #include "Plugins/Process/Utility/RegisterContextFreeBSD_powerpc.h"
19 #include "Plugins/Process/Utility/RegisterContextFreeBSD_x86_64.h"
20 #include "Plugins/Process/Utility/RegisterContextLinux_i386.h"
21 #include "Plugins/Process/Utility/RegisterContextLinux_mips.h"
22 #include "Plugins/Process/Utility/RegisterContextLinux_mips64.h"
23 #ifdef LLDB_ENABLE_ALL
24 #include "Plugins/Process/Utility/RegisterContextLinux_s390x.h"
25 #endif // LLDB_ENABLE_ALL
26 #include "Plugins/Process/Utility/RegisterContextLinux_x86_64.h"
27 #include "Plugins/Process/Utility/RegisterContextNetBSD_x86_64.h"
28 #include "Plugins/Process/Utility/RegisterContextOpenBSD_i386.h"
29 #include "Plugins/Process/Utility/RegisterContextOpenBSD_x86_64.h"
30 #include "Plugins/Process/Utility/RegisterInfoPOSIX_arm.h"
31 #include "Plugins/Process/Utility/RegisterInfoPOSIX_arm64.h"
32 #include "Plugins/Process/Utility/RegisterInfoPOSIX_ppc64le.h"
33 #include "ProcessElfCore.h"
34 #include "RegisterContextPOSIXCore_arm.h"
35 #include "RegisterContextPOSIXCore_arm64.h"
36 #include "RegisterContextPOSIXCore_mips64.h"
37 #include "RegisterContextPOSIXCore_powerpc.h"
38 #include "RegisterContextPOSIXCore_ppc64le.h"
39 #ifdef LLDB_ENABLE_ALL
40 #include "RegisterContextPOSIXCore_s390x.h"
41 #endif // LLDB_ENABLE_ALL
42 #include "RegisterContextPOSIXCore_x86_64.h"
43 #include "ThreadElfCore.h"
44 
45 #include <memory>
46 
47 using namespace lldb;
48 using namespace lldb_private;
49 
50 // Construct a Thread object with given data
51 ThreadElfCore::ThreadElfCore(Process &process, const ThreadData &td)
52     : Thread(process, td.tid), m_thread_name(td.name), m_thread_reg_ctx_sp(),
53       m_signo(td.signo), m_gpregset_data(td.gpregset), m_notes(td.notes) {}
54 
55 ThreadElfCore::~ThreadElfCore() { DestroyThread(); }
56 
57 void ThreadElfCore::RefreshStateAfterStop() {
58   GetRegisterContext()->InvalidateIfNeeded(false);
59 }
60 
61 RegisterContextSP ThreadElfCore::GetRegisterContext() {
62   if (!m_reg_context_sp) {
63     m_reg_context_sp = CreateRegisterContextForFrame(nullptr);
64   }
65   return m_reg_context_sp;
66 }
67 
68 RegisterContextSP
69 ThreadElfCore::CreateRegisterContextForFrame(StackFrame *frame) {
70   RegisterContextSP reg_ctx_sp;
71   uint32_t concrete_frame_idx = 0;
72   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
73 
74   if (frame)
75     concrete_frame_idx = frame->GetConcreteFrameIndex();
76 
77   if (concrete_frame_idx == 0) {
78     if (m_thread_reg_ctx_sp)
79       return m_thread_reg_ctx_sp;
80 
81     ProcessElfCore *process = static_cast<ProcessElfCore *>(GetProcess().get());
82     ArchSpec arch = process->GetArchitecture();
83     RegisterInfoInterface *reg_interface = nullptr;
84 
85     switch (arch.GetTriple().getOS()) {
86     case llvm::Triple::FreeBSD: {
87       switch (arch.GetMachine()) {
88       case llvm::Triple::aarch64:
89         break;
90       case llvm::Triple::arm:
91         reg_interface = new RegisterInfoPOSIX_arm(arch);
92         break;
93       case llvm::Triple::ppc:
94         reg_interface = new RegisterContextFreeBSD_powerpc32(arch);
95         break;
96       case llvm::Triple::ppc64:
97         reg_interface = new RegisterContextFreeBSD_powerpc64(arch);
98         break;
99       case llvm::Triple::mips64:
100         reg_interface = new RegisterContextFreeBSD_mips64(arch);
101         break;
102       case llvm::Triple::x86:
103         reg_interface = new RegisterContextFreeBSD_i386(arch);
104         break;
105       case llvm::Triple::x86_64:
106         reg_interface = new RegisterContextFreeBSD_x86_64(arch);
107         break;
108       default:
109         break;
110       }
111       break;
112     }
113 
114     case llvm::Triple::NetBSD: {
115       switch (arch.GetMachine()) {
116       case llvm::Triple::aarch64:
117         break;
118       case llvm::Triple::x86_64:
119         reg_interface = new RegisterContextNetBSD_x86_64(arch);
120         break;
121       default:
122         break;
123       }
124       break;
125     }
126 
127     case llvm::Triple::Linux: {
128       switch (arch.GetMachine()) {
129       case llvm::Triple::arm:
130         reg_interface = new RegisterInfoPOSIX_arm(arch);
131         break;
132       case llvm::Triple::aarch64:
133         break;
134       case llvm::Triple::mipsel:
135       case llvm::Triple::mips:
136         reg_interface = new RegisterContextLinux_mips(arch);
137         break;
138       case llvm::Triple::mips64el:
139       case llvm::Triple::mips64:
140         reg_interface = new RegisterContextLinux_mips64(arch);
141         break;
142       case llvm::Triple::ppc64le:
143         reg_interface = new RegisterInfoPOSIX_ppc64le(arch);
144         break;
145 #ifdef LLDB_ENABLE_ALL
146       case llvm::Triple::systemz:
147         reg_interface = new RegisterContextLinux_s390x(arch);
148         break;
149 #endif // LLDB_ENABLE_ALL
150       case llvm::Triple::x86:
151         reg_interface = new RegisterContextLinux_i386(arch);
152         break;
153       case llvm::Triple::x86_64:
154         reg_interface = new RegisterContextLinux_x86_64(arch);
155         break;
156       default:
157         break;
158       }
159       break;
160     }
161 
162     case llvm::Triple::OpenBSD: {
163       switch (arch.GetMachine()) {
164       case llvm::Triple::aarch64:
165         break;
166       case llvm::Triple::arm:
167         reg_interface = new RegisterInfoPOSIX_arm(arch);
168         break;
169       case llvm::Triple::x86:
170         reg_interface = new RegisterContextOpenBSD_i386(arch);
171         break;
172       case llvm::Triple::x86_64:
173         reg_interface = new RegisterContextOpenBSD_x86_64(arch);
174         break;
175       default:
176         break;
177       }
178       break;
179     }
180 
181     default:
182       break;
183     }
184 
185     if (!reg_interface && arch.GetMachine() != llvm::Triple::aarch64) {
186       LLDB_LOGF(log, "elf-core::%s:: Architecture(%d) or OS(%d) not supported",
187                 __FUNCTION__, arch.GetMachine(), arch.GetTriple().getOS());
188       assert(false && "Architecture or OS not supported");
189     }
190 
191     switch (arch.GetMachine()) {
192     case llvm::Triple::aarch64:
193       m_thread_reg_ctx_sp = std::make_shared<RegisterContextCorePOSIX_arm64>(
194           *this, std::make_unique<RegisterInfoPOSIX_arm64>(arch),
195           m_gpregset_data, m_notes);
196       break;
197     case llvm::Triple::arm:
198       m_thread_reg_ctx_sp = std::make_shared<RegisterContextCorePOSIX_arm>(
199           *this, reg_interface, m_gpregset_data, m_notes);
200       break;
201     case llvm::Triple::mipsel:
202     case llvm::Triple::mips:
203       m_thread_reg_ctx_sp = std::make_shared<RegisterContextCorePOSIX_mips64>(
204           *this, reg_interface, m_gpregset_data, m_notes);
205       break;
206     case llvm::Triple::mips64:
207     case llvm::Triple::mips64el:
208       m_thread_reg_ctx_sp = std::make_shared<RegisterContextCorePOSIX_mips64>(
209           *this, reg_interface, m_gpregset_data, m_notes);
210       break;
211     case llvm::Triple::ppc:
212     case llvm::Triple::ppc64:
213       m_thread_reg_ctx_sp = std::make_shared<RegisterContextCorePOSIX_powerpc>(
214           *this, reg_interface, m_gpregset_data, m_notes);
215       break;
216     case llvm::Triple::ppc64le:
217       m_thread_reg_ctx_sp = std::make_shared<RegisterContextCorePOSIX_ppc64le>(
218           *this, reg_interface, m_gpregset_data, m_notes);
219       break;
220 #ifdef LLDB_ENABLE_ALL
221     case llvm::Triple::systemz:
222       m_thread_reg_ctx_sp = std::make_shared<RegisterContextCorePOSIX_s390x>(
223           *this, reg_interface, m_gpregset_data, m_notes);
224       break;
225 #endif // LLDB_ENABLE_ALL
226     case llvm::Triple::x86:
227     case llvm::Triple::x86_64:
228       m_thread_reg_ctx_sp = std::make_shared<RegisterContextCorePOSIX_x86_64>(
229           *this, reg_interface, m_gpregset_data, m_notes);
230       break;
231     default:
232       break;
233     }
234 
235     reg_ctx_sp = m_thread_reg_ctx_sp;
236   } else {
237     reg_ctx_sp = GetUnwinder().CreateRegisterContextForFrame(frame);
238   }
239   return reg_ctx_sp;
240 }
241 
242 bool ThreadElfCore::CalculateStopInfo() {
243   ProcessSP process_sp(GetProcess());
244   if (process_sp) {
245     SetStopInfo(StopInfo::CreateStopReasonWithSignal(*this, m_signo));
246     return true;
247   }
248   return false;
249 }
250 
251 // Parse PRSTATUS from NOTE entry
252 ELFLinuxPrStatus::ELFLinuxPrStatus() {
253   memset(this, 0, sizeof(ELFLinuxPrStatus));
254 }
255 
256 size_t ELFLinuxPrStatus::GetSize(const lldb_private::ArchSpec &arch) {
257   constexpr size_t mips_linux_pr_status_size_o32 = 96;
258   constexpr size_t mips_linux_pr_status_size_n32 = 72;
259   constexpr size_t num_ptr_size_members = 10;
260   if (arch.IsMIPS()) {
261     std::string abi = arch.GetTargetABI();
262     assert(!abi.empty() && "ABI is not set");
263     if (!abi.compare("n64"))
264       return sizeof(ELFLinuxPrStatus);
265     else if (!abi.compare("o32"))
266       return mips_linux_pr_status_size_o32;
267     // N32 ABI
268     return mips_linux_pr_status_size_n32;
269   }
270   switch (arch.GetCore()) {
271   case lldb_private::ArchSpec::eCore_x86_32_i386:
272   case lldb_private::ArchSpec::eCore_x86_32_i486:
273     return 72;
274   default:
275     if (arch.GetAddressByteSize() == 8)
276       return sizeof(ELFLinuxPrStatus);
277     else
278       return sizeof(ELFLinuxPrStatus) - num_ptr_size_members * 4;
279   }
280 }
281 
282 Status ELFLinuxPrStatus::Parse(const DataExtractor &data,
283                                const ArchSpec &arch) {
284   Status error;
285   if (GetSize(arch) > data.GetByteSize()) {
286     error.SetErrorStringWithFormat(
287         "NT_PRSTATUS size should be %zu, but the remaining bytes are: %" PRIu64,
288         GetSize(arch), data.GetByteSize());
289     return error;
290   }
291 
292   // Read field by field to correctly account for endianess of both the core
293   // dump and the platform running lldb.
294   offset_t offset = 0;
295   si_signo = data.GetU32(&offset);
296   si_code = data.GetU32(&offset);
297   si_errno = data.GetU32(&offset);
298 
299   pr_cursig = data.GetU16(&offset);
300   offset += 2; // pad
301 
302   pr_sigpend = data.GetAddress(&offset);
303   pr_sighold = data.GetAddress(&offset);
304 
305   pr_pid = data.GetU32(&offset);
306   pr_ppid = data.GetU32(&offset);
307   pr_pgrp = data.GetU32(&offset);
308   pr_sid = data.GetU32(&offset);
309 
310   pr_utime.tv_sec = data.GetAddress(&offset);
311   pr_utime.tv_usec = data.GetAddress(&offset);
312 
313   pr_stime.tv_sec = data.GetAddress(&offset);
314   pr_stime.tv_usec = data.GetAddress(&offset);
315 
316   pr_cutime.tv_sec = data.GetAddress(&offset);
317   pr_cutime.tv_usec = data.GetAddress(&offset);
318 
319   pr_cstime.tv_sec = data.GetAddress(&offset);
320   pr_cstime.tv_usec = data.GetAddress(&offset);
321 
322   return error;
323 }
324 
325 // Parse PRPSINFO from NOTE entry
326 ELFLinuxPrPsInfo::ELFLinuxPrPsInfo() {
327   memset(this, 0, sizeof(ELFLinuxPrPsInfo));
328 }
329 
330 size_t ELFLinuxPrPsInfo::GetSize(const lldb_private::ArchSpec &arch) {
331   constexpr size_t mips_linux_pr_psinfo_size_o32_n32 = 128;
332   if (arch.IsMIPS()) {
333     uint8_t address_byte_size = arch.GetAddressByteSize();
334     if (address_byte_size == 8)
335       return sizeof(ELFLinuxPrPsInfo);
336     return mips_linux_pr_psinfo_size_o32_n32;
337   }
338 
339   switch (arch.GetCore()) {
340   case lldb_private::ArchSpec::eCore_s390x_generic:
341   case lldb_private::ArchSpec::eCore_x86_64_x86_64:
342     return sizeof(ELFLinuxPrPsInfo);
343   case lldb_private::ArchSpec::eCore_x86_32_i386:
344   case lldb_private::ArchSpec::eCore_x86_32_i486:
345     return 124;
346   default:
347     return 0;
348   }
349 }
350 
351 Status ELFLinuxPrPsInfo::Parse(const DataExtractor &data,
352                                const ArchSpec &arch) {
353   Status error;
354   ByteOrder byteorder = data.GetByteOrder();
355   if (GetSize(arch) > data.GetByteSize()) {
356     error.SetErrorStringWithFormat(
357         "NT_PRPSINFO size should be %zu, but the remaining bytes are: %" PRIu64,
358         GetSize(arch), data.GetByteSize());
359     return error;
360   }
361   size_t size = 0;
362   offset_t offset = 0;
363 
364   pr_state = data.GetU8(&offset);
365   pr_sname = data.GetU8(&offset);
366   pr_zomb = data.GetU8(&offset);
367   pr_nice = data.GetU8(&offset);
368   if (data.GetAddressByteSize() == 8) {
369     // Word align the next field on 64 bit.
370     offset += 4;
371   }
372 
373   pr_flag = data.GetAddress(&offset);
374 
375   if (arch.IsMIPS()) {
376     // The pr_uid and pr_gid is always 32 bit irrespective of platforms
377     pr_uid = data.GetU32(&offset);
378     pr_gid = data.GetU32(&offset);
379   } else {
380     // 16 bit on 32 bit platforms, 32 bit on 64 bit platforms
381     pr_uid = data.GetMaxU64(&offset, data.GetAddressByteSize() >> 1);
382     pr_gid = data.GetMaxU64(&offset, data.GetAddressByteSize() >> 1);
383   }
384 
385   pr_pid = data.GetU32(&offset);
386   pr_ppid = data.GetU32(&offset);
387   pr_pgrp = data.GetU32(&offset);
388   pr_sid = data.GetU32(&offset);
389 
390   size = 16;
391   data.ExtractBytes(offset, size, byteorder, pr_fname);
392   offset += size;
393 
394   size = 80;
395   data.ExtractBytes(offset, size, byteorder, pr_psargs);
396   offset += size;
397 
398   return error;
399 }
400 
401 // Parse SIGINFO from NOTE entry
402 ELFLinuxSigInfo::ELFLinuxSigInfo() { memset(this, 0, sizeof(ELFLinuxSigInfo)); }
403 
404 size_t ELFLinuxSigInfo::GetSize(const lldb_private::ArchSpec &arch) {
405   if (arch.IsMIPS())
406     return sizeof(ELFLinuxSigInfo);
407   switch (arch.GetCore()) {
408   case lldb_private::ArchSpec::eCore_x86_64_x86_64:
409     return sizeof(ELFLinuxSigInfo);
410   case lldb_private::ArchSpec::eCore_s390x_generic:
411   case lldb_private::ArchSpec::eCore_x86_32_i386:
412   case lldb_private::ArchSpec::eCore_x86_32_i486:
413     return 12;
414   default:
415     return 0;
416   }
417 }
418 
419 Status ELFLinuxSigInfo::Parse(const DataExtractor &data, const ArchSpec &arch) {
420   Status error;
421   if (GetSize(arch) > data.GetByteSize()) {
422     error.SetErrorStringWithFormat(
423         "NT_SIGINFO size should be %zu, but the remaining bytes are: %" PRIu64,
424         GetSize(arch), data.GetByteSize());
425     return error;
426   }
427 
428   // Parsing from a 32 bit ELF core file, and populating/reusing the structure
429   // properly, because the struct is for the 64 bit version
430   offset_t offset = 0;
431   si_signo = data.GetU32(&offset);
432   si_code = data.GetU32(&offset);
433   si_errno = data.GetU32(&offset);
434 
435   return error;
436 }
437