1 //===-- NativeProcessProtocol.cpp -------------------------------*- C++ -*-===//
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/Host/common/NativeProcessProtocol.h"
10 #include "lldb/Host/Host.h"
11 #include "lldb/Host/common/NativeBreakpointList.h"
12 #include "lldb/Host/common/NativeRegisterContext.h"
13 #include "lldb/Host/common/NativeThreadProtocol.h"
14 #include "lldb/Utility/LLDBAssert.h"
15 #include "lldb/Utility/Log.h"
16 #include "lldb/Utility/State.h"
17 #include "lldb/lldb-enumerations.h"
18
19 #include "llvm/Support/Process.h"
20
21 using namespace lldb;
22 using namespace lldb_private;
23
24 // NativeProcessProtocol Members
25
NativeProcessProtocol(lldb::pid_t pid,int terminal_fd,NativeDelegate & delegate)26 NativeProcessProtocol::NativeProcessProtocol(lldb::pid_t pid, int terminal_fd,
27 NativeDelegate &delegate)
28 : m_pid(pid), m_terminal_fd(terminal_fd) {
29 bool registered = RegisterNativeDelegate(delegate);
30 assert(registered);
31 (void)registered;
32 }
33
Interrupt()34 lldb_private::Status NativeProcessProtocol::Interrupt() {
35 Status error;
36 #if !defined(SIGSTOP)
37 error.SetErrorString("local host does not support signaling");
38 return error;
39 #else
40 return Signal(SIGSTOP);
41 #endif
42 }
43
IgnoreSignals(llvm::ArrayRef<int> signals)44 Status NativeProcessProtocol::IgnoreSignals(llvm::ArrayRef<int> signals) {
45 m_signals_to_ignore.clear();
46 m_signals_to_ignore.insert(signals.begin(), signals.end());
47 return Status();
48 }
49
50 lldb_private::Status
GetMemoryRegionInfo(lldb::addr_t load_addr,MemoryRegionInfo & range_info)51 NativeProcessProtocol::GetMemoryRegionInfo(lldb::addr_t load_addr,
52 MemoryRegionInfo &range_info) {
53 // Default: not implemented.
54 return Status("not implemented");
55 }
56
GetExitStatus()57 llvm::Optional<WaitStatus> NativeProcessProtocol::GetExitStatus() {
58 if (m_state == lldb::eStateExited)
59 return m_exit_status;
60
61 return llvm::None;
62 }
63
SetExitStatus(WaitStatus status,bool bNotifyStateChange)64 bool NativeProcessProtocol::SetExitStatus(WaitStatus status,
65 bool bNotifyStateChange) {
66 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
67 LLDB_LOG(log, "status = {0}, notify = {1}", status, bNotifyStateChange);
68
69 // Exit status already set
70 if (m_state == lldb::eStateExited) {
71 if (m_exit_status)
72 LLDB_LOG(log, "exit status already set to {0}", *m_exit_status);
73 else
74 LLDB_LOG(log, "state is exited, but status not set");
75 return false;
76 }
77
78 m_state = lldb::eStateExited;
79 m_exit_status = status;
80
81 if (bNotifyStateChange)
82 SynchronouslyNotifyProcessStateChanged(lldb::eStateExited);
83
84 return true;
85 }
86
GetThreadAtIndex(uint32_t idx)87 NativeThreadProtocol *NativeProcessProtocol::GetThreadAtIndex(uint32_t idx) {
88 std::lock_guard<std::recursive_mutex> guard(m_threads_mutex);
89 if (idx < m_threads.size())
90 return m_threads[idx].get();
91 return nullptr;
92 }
93
94 NativeThreadProtocol *
GetThreadByIDUnlocked(lldb::tid_t tid)95 NativeProcessProtocol::GetThreadByIDUnlocked(lldb::tid_t tid) {
96 for (const auto &thread : m_threads) {
97 if (thread->GetID() == tid)
98 return thread.get();
99 }
100 return nullptr;
101 }
102
GetThreadByID(lldb::tid_t tid)103 NativeThreadProtocol *NativeProcessProtocol::GetThreadByID(lldb::tid_t tid) {
104 std::lock_guard<std::recursive_mutex> guard(m_threads_mutex);
105 return GetThreadByIDUnlocked(tid);
106 }
107
IsAlive() const108 bool NativeProcessProtocol::IsAlive() const {
109 return m_state != eStateDetached && m_state != eStateExited &&
110 m_state != eStateInvalid && m_state != eStateUnloaded;
111 }
112
113 const NativeWatchpointList::WatchpointMap &
GetWatchpointMap() const114 NativeProcessProtocol::GetWatchpointMap() const {
115 return m_watchpoint_list.GetWatchpointMap();
116 }
117
118 llvm::Optional<std::pair<uint32_t, uint32_t>>
GetHardwareDebugSupportInfo() const119 NativeProcessProtocol::GetHardwareDebugSupportInfo() const {
120 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
121
122 // get any thread
123 NativeThreadProtocol *thread(
124 const_cast<NativeProcessProtocol *>(this)->GetThreadAtIndex(0));
125 if (!thread) {
126 LLDB_LOG(log, "failed to find a thread to grab a NativeRegisterContext!");
127 return llvm::None;
128 }
129
130 NativeRegisterContext ®_ctx = thread->GetRegisterContext();
131 return std::make_pair(reg_ctx.NumSupportedHardwareBreakpoints(),
132 reg_ctx.NumSupportedHardwareWatchpoints());
133 }
134
SetWatchpoint(lldb::addr_t addr,size_t size,uint32_t watch_flags,bool hardware)135 Status NativeProcessProtocol::SetWatchpoint(lldb::addr_t addr, size_t size,
136 uint32_t watch_flags,
137 bool hardware) {
138 // This default implementation assumes setting the watchpoint for the process
139 // will require setting the watchpoint for each of the threads. Furthermore,
140 // it will track watchpoints set for the process and will add them to each
141 // thread that is attached to via the (FIXME implement) OnThreadAttached ()
142 // method.
143
144 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
145
146 // Update the thread list
147 UpdateThreads();
148
149 // Keep track of the threads we successfully set the watchpoint for. If one
150 // of the thread watchpoint setting operations fails, back off and remove the
151 // watchpoint for all the threads that were successfully set so we get back
152 // to a consistent state.
153 std::vector<NativeThreadProtocol *> watchpoint_established_threads;
154
155 // Tell each thread to set a watchpoint. In the event that hardware
156 // watchpoints are requested but the SetWatchpoint fails, try to set a
157 // software watchpoint as a fallback. It's conceivable that if there are
158 // more threads than hardware watchpoints available, some of the threads will
159 // fail to set hardware watchpoints while software ones may be available.
160 std::lock_guard<std::recursive_mutex> guard(m_threads_mutex);
161 for (const auto &thread : m_threads) {
162 assert(thread && "thread list should not have a NULL thread!");
163
164 Status thread_error =
165 thread->SetWatchpoint(addr, size, watch_flags, hardware);
166 if (thread_error.Fail() && hardware) {
167 // Try software watchpoints since we failed on hardware watchpoint
168 // setting and we may have just run out of hardware watchpoints.
169 thread_error = thread->SetWatchpoint(addr, size, watch_flags, false);
170 if (thread_error.Success())
171 LLDB_LOG(log,
172 "hardware watchpoint requested but software watchpoint set");
173 }
174
175 if (thread_error.Success()) {
176 // Remember that we set this watchpoint successfully in case we need to
177 // clear it later.
178 watchpoint_established_threads.push_back(thread.get());
179 } else {
180 // Unset the watchpoint for each thread we successfully set so that we
181 // get back to a consistent state of "not set" for the watchpoint.
182 for (auto unwatch_thread_sp : watchpoint_established_threads) {
183 Status remove_error = unwatch_thread_sp->RemoveWatchpoint(addr);
184 if (remove_error.Fail())
185 LLDB_LOG(log, "RemoveWatchpoint failed for pid={0}, tid={1}: {2}",
186 GetID(), unwatch_thread_sp->GetID(), remove_error);
187 }
188
189 return thread_error;
190 }
191 }
192 return m_watchpoint_list.Add(addr, size, watch_flags, hardware);
193 }
194
RemoveWatchpoint(lldb::addr_t addr)195 Status NativeProcessProtocol::RemoveWatchpoint(lldb::addr_t addr) {
196 // Update the thread list
197 UpdateThreads();
198
199 Status overall_error;
200
201 std::lock_guard<std::recursive_mutex> guard(m_threads_mutex);
202 for (const auto &thread : m_threads) {
203 assert(thread && "thread list should not have a NULL thread!");
204
205 const Status thread_error = thread->RemoveWatchpoint(addr);
206 if (thread_error.Fail()) {
207 // Keep track of the first thread error if any threads fail. We want to
208 // try to remove the watchpoint from every thread, though, even if one or
209 // more have errors.
210 if (!overall_error.Fail())
211 overall_error = thread_error;
212 }
213 }
214 const Status error = m_watchpoint_list.Remove(addr);
215 return overall_error.Fail() ? overall_error : error;
216 }
217
218 const HardwareBreakpointMap &
GetHardwareBreakpointMap() const219 NativeProcessProtocol::GetHardwareBreakpointMap() const {
220 return m_hw_breakpoints_map;
221 }
222
SetHardwareBreakpoint(lldb::addr_t addr,size_t size)223 Status NativeProcessProtocol::SetHardwareBreakpoint(lldb::addr_t addr,
224 size_t size) {
225 // This default implementation assumes setting a hardware breakpoint for this
226 // process will require setting same hardware breakpoint for each of its
227 // existing threads. New thread will do the same once created.
228 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
229
230 // Update the thread list
231 UpdateThreads();
232
233 // Exit here if target does not have required hardware breakpoint capability.
234 auto hw_debug_cap = GetHardwareDebugSupportInfo();
235
236 if (hw_debug_cap == llvm::None || hw_debug_cap->first == 0 ||
237 hw_debug_cap->first <= m_hw_breakpoints_map.size())
238 return Status("Target does not have required no of hardware breakpoints");
239
240 // Vector below stores all thread pointer for which we have we successfully
241 // set this hardware breakpoint. If any of the current process threads fails
242 // to set this hardware breakpoint then roll back and remove this breakpoint
243 // for all the threads that had already set it successfully.
244 std::vector<NativeThreadProtocol *> breakpoint_established_threads;
245
246 // Request to set a hardware breakpoint for each of current process threads.
247 std::lock_guard<std::recursive_mutex> guard(m_threads_mutex);
248 for (const auto &thread : m_threads) {
249 assert(thread && "thread list should not have a NULL thread!");
250
251 Status thread_error = thread->SetHardwareBreakpoint(addr, size);
252 if (thread_error.Success()) {
253 // Remember that we set this breakpoint successfully in case we need to
254 // clear it later.
255 breakpoint_established_threads.push_back(thread.get());
256 } else {
257 // Unset the breakpoint for each thread we successfully set so that we
258 // get back to a consistent state of "not set" for this hardware
259 // breakpoint.
260 for (auto rollback_thread_sp : breakpoint_established_threads) {
261 Status remove_error =
262 rollback_thread_sp->RemoveHardwareBreakpoint(addr);
263 if (remove_error.Fail())
264 LLDB_LOG(log,
265 "RemoveHardwareBreakpoint failed for pid={0}, tid={1}: {2}",
266 GetID(), rollback_thread_sp->GetID(), remove_error);
267 }
268
269 return thread_error;
270 }
271 }
272
273 // Register new hardware breakpoint into hardware breakpoints map of current
274 // process.
275 m_hw_breakpoints_map[addr] = {addr, size};
276
277 return Status();
278 }
279
RemoveHardwareBreakpoint(lldb::addr_t addr)280 Status NativeProcessProtocol::RemoveHardwareBreakpoint(lldb::addr_t addr) {
281 // Update the thread list
282 UpdateThreads();
283
284 Status error;
285
286 std::lock_guard<std::recursive_mutex> guard(m_threads_mutex);
287 for (const auto &thread : m_threads) {
288 assert(thread && "thread list should not have a NULL thread!");
289 error = thread->RemoveHardwareBreakpoint(addr);
290 }
291
292 // Also remove from hardware breakpoint map of current process.
293 m_hw_breakpoints_map.erase(addr);
294
295 return error;
296 }
297
RegisterNativeDelegate(NativeDelegate & native_delegate)298 bool NativeProcessProtocol::RegisterNativeDelegate(
299 NativeDelegate &native_delegate) {
300 std::lock_guard<std::recursive_mutex> guard(m_delegates_mutex);
301 if (std::find(m_delegates.begin(), m_delegates.end(), &native_delegate) !=
302 m_delegates.end())
303 return false;
304
305 m_delegates.push_back(&native_delegate);
306 native_delegate.InitializeDelegate(this);
307 return true;
308 }
309
UnregisterNativeDelegate(NativeDelegate & native_delegate)310 bool NativeProcessProtocol::UnregisterNativeDelegate(
311 NativeDelegate &native_delegate) {
312 std::lock_guard<std::recursive_mutex> guard(m_delegates_mutex);
313
314 const auto initial_size = m_delegates.size();
315 m_delegates.erase(
316 remove(m_delegates.begin(), m_delegates.end(), &native_delegate),
317 m_delegates.end());
318
319 // We removed the delegate if the count of delegates shrank after removing
320 // all copies of the given native_delegate from the vector.
321 return m_delegates.size() < initial_size;
322 }
323
SynchronouslyNotifyProcessStateChanged(lldb::StateType state)324 void NativeProcessProtocol::SynchronouslyNotifyProcessStateChanged(
325 lldb::StateType state) {
326 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
327
328 std::lock_guard<std::recursive_mutex> guard(m_delegates_mutex);
329 for (auto native_delegate : m_delegates)
330 native_delegate->ProcessStateChanged(this, state);
331
332 if (log) {
333 if (!m_delegates.empty()) {
334 LLDB_LOGF(log,
335 "NativeProcessProtocol::%s: sent state notification [%s] "
336 "from process %" PRIu64,
337 __FUNCTION__, lldb_private::StateAsCString(state), GetID());
338 } else {
339 LLDB_LOGF(log,
340 "NativeProcessProtocol::%s: would send state notification "
341 "[%s] from process %" PRIu64 ", but no delegates",
342 __FUNCTION__, lldb_private::StateAsCString(state), GetID());
343 }
344 }
345 }
346
NotifyDidExec()347 void NativeProcessProtocol::NotifyDidExec() {
348 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
349 LLDB_LOGF(log, "NativeProcessProtocol::%s - preparing to call delegates",
350 __FUNCTION__);
351
352 {
353 std::lock_guard<std::recursive_mutex> guard(m_delegates_mutex);
354 for (auto native_delegate : m_delegates)
355 native_delegate->DidExec(this);
356 }
357 }
358
SetSoftwareBreakpoint(lldb::addr_t addr,uint32_t size_hint)359 Status NativeProcessProtocol::SetSoftwareBreakpoint(lldb::addr_t addr,
360 uint32_t size_hint) {
361 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
362 LLDB_LOG(log, "addr = {0:x}, size_hint = {1}", addr, size_hint);
363
364 auto it = m_software_breakpoints.find(addr);
365 if (it != m_software_breakpoints.end()) {
366 ++it->second.ref_count;
367 return Status();
368 }
369 auto expected_bkpt = EnableSoftwareBreakpoint(addr, size_hint);
370 if (!expected_bkpt)
371 return Status(expected_bkpt.takeError());
372
373 m_software_breakpoints.emplace(addr, std::move(*expected_bkpt));
374 return Status();
375 }
376
RemoveSoftwareBreakpoint(lldb::addr_t addr)377 Status NativeProcessProtocol::RemoveSoftwareBreakpoint(lldb::addr_t addr) {
378 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
379 LLDB_LOG(log, "addr = {0:x}", addr);
380 auto it = m_software_breakpoints.find(addr);
381 if (it == m_software_breakpoints.end())
382 return Status("Breakpoint not found.");
383 assert(it->second.ref_count > 0);
384 if (--it->second.ref_count > 0)
385 return Status();
386
387 // This is the last reference. Let's remove the breakpoint.
388 Status error;
389
390 // Clear a software breakpoint instruction
391 llvm::SmallVector<uint8_t, 4> curr_break_op(
392 it->second.breakpoint_opcodes.size(), 0);
393
394 // Read the breakpoint opcode
395 size_t bytes_read = 0;
396 error =
397 ReadMemory(addr, curr_break_op.data(), curr_break_op.size(), bytes_read);
398 if (error.Fail() || bytes_read < curr_break_op.size()) {
399 return Status("addr=0x%" PRIx64
400 ": tried to read %zu bytes but only read %zu",
401 addr, curr_break_op.size(), bytes_read);
402 }
403 const auto &saved = it->second.saved_opcodes;
404 // Make sure the breakpoint opcode exists at this address
405 if (makeArrayRef(curr_break_op) != it->second.breakpoint_opcodes) {
406 if (curr_break_op != it->second.saved_opcodes)
407 return Status("Original breakpoint trap is no longer in memory.");
408 LLDB_LOG(log,
409 "Saved opcodes ({0:@[x]}) have already been restored at {1:x}.",
410 llvm::make_range(saved.begin(), saved.end()), addr);
411 } else {
412 // We found a valid breakpoint opcode at this address, now restore the
413 // saved opcode.
414 size_t bytes_written = 0;
415 error = WriteMemory(addr, saved.data(), saved.size(), bytes_written);
416 if (error.Fail() || bytes_written < saved.size()) {
417 return Status("addr=0x%" PRIx64
418 ": tried to write %zu bytes but only wrote %zu",
419 addr, saved.size(), bytes_written);
420 }
421
422 // Verify that our original opcode made it back to the inferior
423 llvm::SmallVector<uint8_t, 4> verify_opcode(saved.size(), 0);
424 size_t verify_bytes_read = 0;
425 error = ReadMemory(addr, verify_opcode.data(), verify_opcode.size(),
426 verify_bytes_read);
427 if (error.Fail() || verify_bytes_read < verify_opcode.size()) {
428 return Status("addr=0x%" PRIx64
429 ": tried to read %zu verification bytes but only read %zu",
430 addr, verify_opcode.size(), verify_bytes_read);
431 }
432 if (verify_opcode != saved)
433 LLDB_LOG(log, "Restoring bytes at {0:x}: {1:@[x]}", addr,
434 llvm::make_range(saved.begin(), saved.end()));
435 }
436
437 m_software_breakpoints.erase(it);
438 return Status();
439 }
440
441 llvm::Expected<NativeProcessProtocol::SoftwareBreakpoint>
EnableSoftwareBreakpoint(lldb::addr_t addr,uint32_t size_hint)442 NativeProcessProtocol::EnableSoftwareBreakpoint(lldb::addr_t addr,
443 uint32_t size_hint) {
444 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
445
446 auto expected_trap = GetSoftwareBreakpointTrapOpcode(size_hint);
447 if (!expected_trap)
448 return expected_trap.takeError();
449
450 llvm::SmallVector<uint8_t, 4> saved_opcode_bytes(expected_trap->size(), 0);
451 // Save the original opcodes by reading them so we can restore later.
452 size_t bytes_read = 0;
453 Status error = ReadMemory(addr, saved_opcode_bytes.data(),
454 saved_opcode_bytes.size(), bytes_read);
455 if (error.Fail())
456 return error.ToError();
457
458 // Ensure we read as many bytes as we expected.
459 if (bytes_read != saved_opcode_bytes.size()) {
460 return llvm::createStringError(
461 llvm::inconvertibleErrorCode(),
462 "Failed to read memory while attempting to set breakpoint: attempted "
463 "to read {0} bytes but only read {1}.",
464 saved_opcode_bytes.size(), bytes_read);
465 }
466
467 LLDB_LOG(
468 log, "Overwriting bytes at {0:x}: {1:@[x]}", addr,
469 llvm::make_range(saved_opcode_bytes.begin(), saved_opcode_bytes.end()));
470
471 // Write a software breakpoint in place of the original opcode.
472 size_t bytes_written = 0;
473 error = WriteMemory(addr, expected_trap->data(), expected_trap->size(),
474 bytes_written);
475 if (error.Fail())
476 return error.ToError();
477
478 // Ensure we wrote as many bytes as we expected.
479 if (bytes_written != expected_trap->size()) {
480 return llvm::createStringError(
481 llvm::inconvertibleErrorCode(),
482 "Failed write memory while attempting to set "
483 "breakpoint: attempted to write {0} bytes but only wrote {1}",
484 expected_trap->size(), bytes_written);
485 }
486
487 llvm::SmallVector<uint8_t, 4> verify_bp_opcode_bytes(expected_trap->size(),
488 0);
489 size_t verify_bytes_read = 0;
490 error = ReadMemory(addr, verify_bp_opcode_bytes.data(),
491 verify_bp_opcode_bytes.size(), verify_bytes_read);
492 if (error.Fail())
493 return error.ToError();
494
495 // Ensure we read as many verification bytes as we expected.
496 if (verify_bytes_read != verify_bp_opcode_bytes.size()) {
497 return llvm::createStringError(
498 llvm::inconvertibleErrorCode(),
499 "Failed to read memory while "
500 "attempting to verify breakpoint: attempted to read {0} bytes "
501 "but only read {1}",
502 verify_bp_opcode_bytes.size(), verify_bytes_read);
503 }
504
505 if (llvm::makeArrayRef(verify_bp_opcode_bytes.data(), verify_bytes_read) !=
506 *expected_trap) {
507 return llvm::createStringError(
508 llvm::inconvertibleErrorCode(),
509 "Verification of software breakpoint "
510 "writing failed - trap opcodes not successfully read back "
511 "after writing when setting breakpoint at {0:x}",
512 addr);
513 }
514
515 LLDB_LOG(log, "addr = {0:x}: SUCCESS", addr);
516 return SoftwareBreakpoint{1, saved_opcode_bytes, *expected_trap};
517 }
518
519 llvm::Expected<llvm::ArrayRef<uint8_t>>
GetSoftwareBreakpointTrapOpcode(size_t size_hint)520 NativeProcessProtocol::GetSoftwareBreakpointTrapOpcode(size_t size_hint) {
521 static const uint8_t g_aarch64_opcode[] = {0x00, 0x00, 0x20, 0xd4};
522 static const uint8_t g_i386_opcode[] = {0xCC};
523 static const uint8_t g_mips64_opcode[] = {0x00, 0x00, 0x00, 0x0d};
524 static const uint8_t g_mips64el_opcode[] = {0x0d, 0x00, 0x00, 0x00};
525 static const uint8_t g_s390x_opcode[] = {0x00, 0x01};
526 static const uint8_t g_ppc64le_opcode[] = {0x08, 0x00, 0xe0, 0x7f}; // trap
527
528 switch (GetArchitecture().GetMachine()) {
529 case llvm::Triple::aarch64:
530 case llvm::Triple::aarch64_32:
531 return llvm::makeArrayRef(g_aarch64_opcode);
532
533 case llvm::Triple::x86:
534 case llvm::Triple::x86_64:
535 return llvm::makeArrayRef(g_i386_opcode);
536
537 case llvm::Triple::mips:
538 case llvm::Triple::mips64:
539 return llvm::makeArrayRef(g_mips64_opcode);
540
541 case llvm::Triple::mipsel:
542 case llvm::Triple::mips64el:
543 return llvm::makeArrayRef(g_mips64el_opcode);
544
545 case llvm::Triple::systemz:
546 return llvm::makeArrayRef(g_s390x_opcode);
547
548 case llvm::Triple::ppc64le:
549 return llvm::makeArrayRef(g_ppc64le_opcode);
550
551 default:
552 return llvm::createStringError(llvm::inconvertibleErrorCode(),
553 "CPU type not supported!");
554 }
555 }
556
GetSoftwareBreakpointPCOffset()557 size_t NativeProcessProtocol::GetSoftwareBreakpointPCOffset() {
558 switch (GetArchitecture().GetMachine()) {
559 case llvm::Triple::x86:
560 case llvm::Triple::x86_64:
561 case llvm::Triple::systemz:
562 // These architectures report increment the PC after breakpoint is hit.
563 return cantFail(GetSoftwareBreakpointTrapOpcode(0)).size();
564
565 case llvm::Triple::arm:
566 case llvm::Triple::aarch64:
567 case llvm::Triple::aarch64_32:
568 case llvm::Triple::mips64:
569 case llvm::Triple::mips64el:
570 case llvm::Triple::mips:
571 case llvm::Triple::mipsel:
572 case llvm::Triple::ppc64le:
573 // On these architectures the PC doesn't get updated for breakpoint hits.
574 return 0;
575
576 default:
577 llvm_unreachable("CPU type not supported!");
578 }
579 }
580
FixupBreakpointPCAsNeeded(NativeThreadProtocol & thread)581 void NativeProcessProtocol::FixupBreakpointPCAsNeeded(
582 NativeThreadProtocol &thread) {
583 Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS);
584
585 Status error;
586
587 // Find out the size of a breakpoint (might depend on where we are in the
588 // code).
589 NativeRegisterContext &context = thread.GetRegisterContext();
590
591 uint32_t breakpoint_size = GetSoftwareBreakpointPCOffset();
592 LLDB_LOG(log, "breakpoint size: {0}", breakpoint_size);
593 if (breakpoint_size == 0)
594 return;
595
596 // First try probing for a breakpoint at a software breakpoint location: PC -
597 // breakpoint size.
598 const lldb::addr_t initial_pc_addr = context.GetPCfromBreakpointLocation();
599 lldb::addr_t breakpoint_addr = initial_pc_addr;
600 // Do not allow breakpoint probe to wrap around.
601 if (breakpoint_addr >= breakpoint_size)
602 breakpoint_addr -= breakpoint_size;
603
604 if (m_software_breakpoints.count(breakpoint_addr) == 0) {
605 // We didn't find one at a software probe location. Nothing to do.
606 LLDB_LOG(log,
607 "pid {0} no lldb software breakpoint found at current pc with "
608 "adjustment: {1}",
609 GetID(), breakpoint_addr);
610 return;
611 }
612
613 //
614 // We have a software breakpoint and need to adjust the PC.
615 //
616
617 // Change the program counter.
618 LLDB_LOG(log, "pid {0} tid {1}: changing PC from {2:x} to {3:x}", GetID(),
619 thread.GetID(), initial_pc_addr, breakpoint_addr);
620
621 error = context.SetPC(breakpoint_addr);
622 if (error.Fail()) {
623 // This can happen in case the process was killed between the time we read
624 // the PC and when we are updating it. There's nothing better to do than to
625 // swallow the error.
626 LLDB_LOG(log, "pid {0} tid {1}: failed to set PC: {2}", GetID(),
627 thread.GetID(), error);
628 }
629 }
630
RemoveBreakpoint(lldb::addr_t addr,bool hardware)631 Status NativeProcessProtocol::RemoveBreakpoint(lldb::addr_t addr,
632 bool hardware) {
633 if (hardware)
634 return RemoveHardwareBreakpoint(addr);
635 else
636 return RemoveSoftwareBreakpoint(addr);
637 }
638
ReadMemoryWithoutTrap(lldb::addr_t addr,void * buf,size_t size,size_t & bytes_read)639 Status NativeProcessProtocol::ReadMemoryWithoutTrap(lldb::addr_t addr,
640 void *buf, size_t size,
641 size_t &bytes_read) {
642 Status error = ReadMemory(addr, buf, size, bytes_read);
643 if (error.Fail())
644 return error;
645
646 auto data =
647 llvm::makeMutableArrayRef(static_cast<uint8_t *>(buf), bytes_read);
648 for (const auto &pair : m_software_breakpoints) {
649 lldb::addr_t bp_addr = pair.first;
650 auto saved_opcodes = makeArrayRef(pair.second.saved_opcodes);
651
652 if (bp_addr + saved_opcodes.size() < addr || addr + bytes_read <= bp_addr)
653 continue; // Breapoint not in range, ignore
654
655 if (bp_addr < addr) {
656 saved_opcodes = saved_opcodes.drop_front(addr - bp_addr);
657 bp_addr = addr;
658 }
659 auto bp_data = data.drop_front(bp_addr - addr);
660 std::copy_n(saved_opcodes.begin(),
661 std::min(saved_opcodes.size(), bp_data.size()),
662 bp_data.begin());
663 }
664 return Status();
665 }
666
667 llvm::Expected<llvm::StringRef>
ReadCStringFromMemory(lldb::addr_t addr,char * buffer,size_t max_size,size_t & total_bytes_read)668 NativeProcessProtocol::ReadCStringFromMemory(lldb::addr_t addr, char *buffer,
669 size_t max_size,
670 size_t &total_bytes_read) {
671 static const size_t cache_line_size =
672 llvm::sys::Process::getPageSizeEstimate();
673 size_t bytes_read = 0;
674 size_t bytes_left = max_size;
675 addr_t curr_addr = addr;
676 size_t string_size;
677 char *curr_buffer = buffer;
678 total_bytes_read = 0;
679 Status status;
680
681 while (bytes_left > 0 && status.Success()) {
682 addr_t cache_line_bytes_left =
683 cache_line_size - (curr_addr % cache_line_size);
684 addr_t bytes_to_read = std::min<addr_t>(bytes_left, cache_line_bytes_left);
685 status = ReadMemory(curr_addr, static_cast<void *>(curr_buffer),
686 bytes_to_read, bytes_read);
687
688 if (bytes_read == 0)
689 break;
690
691 void *str_end = std::memchr(curr_buffer, '\0', bytes_read);
692 if (str_end != nullptr) {
693 total_bytes_read =
694 static_cast<size_t>((static_cast<char *>(str_end) - buffer + 1));
695 status.Clear();
696 break;
697 }
698
699 total_bytes_read += bytes_read;
700 curr_buffer += bytes_read;
701 curr_addr += bytes_read;
702 bytes_left -= bytes_read;
703 }
704
705 string_size = total_bytes_read - 1;
706
707 // Make sure we return a null terminated string.
708 if (bytes_left == 0 && max_size > 0 && buffer[max_size - 1] != '\0') {
709 buffer[max_size - 1] = '\0';
710 total_bytes_read--;
711 }
712
713 if (!status.Success())
714 return status.ToError();
715
716 return llvm::StringRef(buffer, string_size);
717 }
718
GetState() const719 lldb::StateType NativeProcessProtocol::GetState() const {
720 std::lock_guard<std::recursive_mutex> guard(m_state_mutex);
721 return m_state;
722 }
723
SetState(lldb::StateType state,bool notify_delegates)724 void NativeProcessProtocol::SetState(lldb::StateType state,
725 bool notify_delegates) {
726 std::lock_guard<std::recursive_mutex> guard(m_state_mutex);
727
728 if (state == m_state)
729 return;
730
731 m_state = state;
732
733 if (StateIsStoppedState(state, false)) {
734 ++m_stop_id;
735
736 // Give process a chance to do any stop id bump processing, such as
737 // clearing cached data that is invalidated each time the process runs.
738 // Note if/when we support some threads running, we'll end up needing to
739 // manage this per thread and per process.
740 DoStopIDBumped(m_stop_id);
741 }
742
743 // Optionally notify delegates of the state change.
744 if (notify_delegates)
745 SynchronouslyNotifyProcessStateChanged(state);
746 }
747
GetStopID() const748 uint32_t NativeProcessProtocol::GetStopID() const {
749 std::lock_guard<std::recursive_mutex> guard(m_state_mutex);
750 return m_stop_id;
751 }
752
DoStopIDBumped(uint32_t)753 void NativeProcessProtocol::DoStopIDBumped(uint32_t /* newBumpId */) {
754 // Default implementation does nothing.
755 }
756
757 NativeProcessProtocol::Factory::~Factory() = default;
758