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