LLDB  mainline
NativeProcessProtocol.cpp
Go to the documentation of this file.
1 //===-- NativeProcessProtocol.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 
10 #include "lldb/Host/Host.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 
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 
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 
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 
52  MemoryRegionInfo &range_info) {
53  // Default: not implemented.
54  return Status("not implemented");
55 }
56 
57 llvm::Optional<WaitStatus> NativeProcessProtocol::GetExitStatus() {
59  return m_exit_status;
60 
61  return llvm::None;
62 }
63 
65  bool bNotifyStateChange) {
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 
79  m_exit_status = status;
80 
81  if (bNotifyStateChange)
83 
84  return true;
85 }
86 
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 
96  for (const auto &thread : m_threads) {
97  if (thread->GetID() == tid)
98  return thread.get();
99  }
100  return nullptr;
101 }
102 
104  std::lock_guard<std::recursive_mutex> guard(m_threads_mutex);
105  return GetThreadByIDUnlocked(tid);
106 }
107 
109  return m_state != eStateDetached && m_state != eStateExited &&
111 }
112 
116 }
117 
118 llvm::Optional<std::pair<uint32_t, uint32_t>>
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 &reg_ctx = thread->GetRegisterContext();
131  return std::make_pair(reg_ctx.NumSupportedHardwareBreakpoints(),
133 }
134 
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 
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 
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 &
220  return m_hw_breakpoints_map;
221 }
222 
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.
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 
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 
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 
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 
325  lldb::StateType state) {
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 
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 
360  uint32_t size_hint) {
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 
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>
443  uint32_t size_hint) {
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>>
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 
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 
582  NativeThreadProtocol &thread) {
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 
632  bool hardware) {
633  if (hardware)
634  return RemoveHardwareBreakpoint(addr);
635  else
636  return RemoveSoftwareBreakpoint(addr);
637 }
638 
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; // Breakpoint 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>
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 
720  std::lock_guard<std::recursive_mutex> guard(m_state_mutex);
721  return m_state;
722 }
723 
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.
741  }
742 
743  // Optionally notify delegates of the state change.
744  if (notify_delegates)
746 }
747 
749  std::lock_guard<std::recursive_mutex> guard(m_state_mutex);
750  return m_stop_id;
751 }
752 
754  // Default implementation does nothing.
755 }
756 
virtual Status SetWatchpoint(lldb::addr_t addr, size_t size, uint32_t watch_flags, bool hardware)
virtual Status WriteMemory(lldb::addr_t addr, const void *buf, size_t size, size_t &bytes_written)=0
llvm::Error ToError() const
Definition: Status.cpp:90
virtual void InitializeDelegate(NativeProcessProtocol *process)=0
virtual NativeRegisterContext & GetRegisterContext()=0
#define LIBLLDB_LOG_PROCESS
Definition: Logging.h:15
const char * StateAsCString(lldb::StateType state)
Converts a StateType to a C string.
Definition: State.cpp:14
A class that represents a running process on the host machine.
virtual Status RemoveWatchpoint(lldb::addr_t addr)
virtual const NativeWatchpointList::WatchpointMap & GetWatchpointMap() const
virtual llvm::Optional< WaitStatus > GetExitStatus()
virtual Status IgnoreSignals(llvm::ArrayRef< int > signals)
std::vector< NativeDelegate * > m_delegates
virtual const HardwareBreakpointMap & GetHardwareBreakpointMap() const
void SynchronouslyNotifyProcessStateChanged(lldb::StateType state)
virtual Status SetHardwareBreakpoint(lldb::addr_t addr, size_t size)
bool UnregisterNativeDelegate(NativeDelegate &native_delegate)
Unregister a native delegate previously registered.
virtual bool SetExitStatus(WaitStatus status, bool bNotifyStateChange)
virtual lldb::addr_t GetPCfromBreakpointLocation(lldb::addr_t fail_value=LLDB_INVALID_ADDRESS)
bool RegisterNativeDelegate(NativeDelegate &native_delegate)
Register a native delegate.
Status ReadMemoryWithoutTrap(lldb::addr_t addr, void *buf, size_t size, size_t &bytes_read)
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
Definition: Log.h:242
NativeThreadProtocol * GetThreadByID(lldb::tid_t tid)
llvm::Expected< SoftwareBreakpoint > EnableSoftwareBreakpoint(lldb::addr_t addr, uint32_t size_hint)
#define SIGSTOP
virtual Status RemoveBreakpoint(lldb::addr_t addr, bool hardware=false)
llvm::Optional< WaitStatus > m_exit_status
virtual llvm::Optional< std::pair< uint32_t, uint32_t > > GetHardwareDebugSupportInfo() const
const WatchpointMap & GetWatchpointMap() const
Status RemoveSoftwareBreakpoint(lldb::addr_t addr)
Process has exited and can&#39;t be examined.
virtual Status RemoveHardwareBreakpoint(lldb::addr_t addr)
bool StateIsStoppedState(lldb::StateType state, bool must_exist)
Check if a state represents a state where the process or thread is stopped.
Definition: State.cpp:89
virtual llvm::Expected< llvm::ArrayRef< uint8_t > > GetSoftwareBreakpointTrapOpcode(size_t size_hint)
static llvm::raw_ostream & error(Stream &strm)
Log * GetLogIfAllCategoriesSet(uint32_t mask)
Definition: Logging.cpp:58
#define LIBLLDB_LOG_BREAKPOINTS
Definition: Logging.h:19
virtual const ArchSpec & GetArchitecture() const =0
Process has been detached and can&#39;t be examined.
StateType
Process and Thread States.
virtual Status ReadMemory(lldb::addr_t addr, void *buf, size_t size, size_t &bytes_read)=0
void NotifyDidExec()
Notify the delegate that an exec occurred.
virtual size_t GetSoftwareBreakpointPCOffset()
Return the offset of the PC relative to the software breakpoint that was hit.
uint64_t tid_t
Definition: lldb-types.h:86
void SetErrorString(llvm::StringRef err_str)
Set the current error string to err_str.
Definition: Status.cpp:242
virtual void DoStopIDBumped(uint32_t newBumpId)
virtual Status GetMemoryRegionInfo(lldb::addr_t load_addr, MemoryRegionInfo &range_info)
bool Success() const
Test for success condition.
Definition: Status.cpp:288
Status Add(lldb::addr_t addr, size_t size, uint32_t watch_flags, bool hardware)
Process is object is valid, but not currently loaded.
virtual Status Interrupt()
Tells a process to interrupt all operations as if by a Ctrl-C.
void FixupBreakpointPCAsNeeded(NativeThreadProtocol &thread)
Status SetSoftwareBreakpoint(lldb::addr_t addr, uint32_t size_hint)
#define LLDB_LOGF(log,...)
Definition: Log.h:249
uint64_t addr_t
Definition: lldb-types.h:83
std::map< lldb::addr_t, HardwareBreakpoint > HardwareBreakpointMap
void SetState(lldb::StateType state, bool notify_delegates=true)
bool Fail() const
Test for error condition.
Definition: Status.cpp:182
Log * GetLogIfAnyCategoriesSet(uint32_t mask)
Definition: Logging.cpp:62
Definition: SBAddress.h:15
std::map< lldb::addr_t, NativeWatchpoint > WatchpointMap
uint64_t pid_t
Definition: lldb-types.h:85
llvm::Expected< llvm::StringRef > ReadCStringFromMemory(lldb::addr_t addr, char *buffer, size_t max_size, size_t &total_bytes_read)
Reads a null terminated string from memory.
std::unordered_map< lldb::addr_t, SoftwareBreakpoint > m_software_breakpoints
virtual Status Signal(int signo)=0
Sends a process a UNIX signal signal.
std::vector< std::unique_ptr< NativeThreadProtocol > > m_threads
NativeThreadProtocol * GetThreadByIDUnlocked(lldb::tid_t tid)
An error handling class.
Definition: Status.h:44
NativeThreadProtocol * GetThreadAtIndex(uint32_t idx)